@langchain/core 1.2.4 → 1.2.6

package/dist/structured_query/base.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":["Visitor","Operators","Comparators","castValue","isFilterEmpty"],"sources":["../../src/structured_query/base.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n  Visitor,\n  VisitorComparisonResult,\n  VisitorOperationResult,\n  VisitorResult,\n  VisitorStructuredQueryResult,\n} from \"./ir.js\";\nimport { isFilterEmpty, castValue } from \"./utils.js\";\n\n/**\n * Options object for the BasicTranslator class. Specifies the allowed\n * operators and comparators.\n */\nexport type TranslatorOpts = {\n  allowedOperators: Operator[];\n  allowedComparators: Comparator[];\n};\n\n/**\n * Abstract class that provides a blueprint for creating specific\n * translator classes. Defines two abstract methods: formatFunction and\n * mergeFilters.\n */\nexport abstract class BaseTranslator<\n  T extends VectorStore = VectorStore,\n> extends Visitor<T> {\n  /**\n   * Formats a given function (either an operator or a comparator) into a\n   * string.\n   * @param func The function to format.\n   * @returns Formatted string representation of the function.\n   */\n  abstract formatFunction(func: Operator | Comparator): string;\n\n  /**\n   * Merges two filters into one, using a specified merge type.\n   * @param defaultFilter The default filter.\n   * @param generatedFilter The generated filter.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.\n   * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.\n   * @returns The merged filter, or undefined if both filters are empty.\n   */\n  abstract mergeFilters(\n    defaultFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    generatedFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    mergeType?: \"and\" | \"or\" | \"replace\",\n    forceDefaultFilter?: boolean\n  ): this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined;\n}\n\n/**\n * Class that extends the BaseTranslator class and provides concrete\n * implementations for the abstract methods. Also declares three types:\n * VisitOperationOutput, VisitComparisonOutput, and\n * VisitStructuredQueryOutput, which are used as the return types for the\n * visitOperation, visitComparison, and visitStructuredQuery methods\n * respectively.\n */\nexport class BasicTranslator<\n  T extends VectorStore = VectorStore,\n> extends BaseTranslator<T> {\n  declare VisitOperationOutput: VisitorOperationResult;\n\n  declare VisitComparisonOutput: VisitorComparisonResult;\n\n  declare VisitStructuredQueryOutput: VisitorStructuredQueryResult;\n\n  allowedOperators: Operator[];\n\n  allowedComparators: Comparator[];\n\n  constructor(opts?: TranslatorOpts) {\n    super();\n    this.allowedOperators = opts?.allowedOperators ?? [\n      Operators.and,\n      Operators.or,\n    ];\n    this.allowedComparators = opts?.allowedComparators ?? [\n      Comparators.eq,\n      Comparators.ne,\n      Comparators.gt,\n      Comparators.gte,\n      Comparators.lt,\n      Comparators.lte,\n    ];\n  }\n\n  formatFunction(func: Operator | Comparator): string {\n    if (func in Comparators) {\n      if (\n        this.allowedComparators.length > 0 &&\n        this.allowedComparators.indexOf(func as Comparator) === -1\n      ) {\n        throw new Error(\n          `Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else if (func in Operators) {\n      if (\n        this.allowedOperators.length > 0 &&\n        this.allowedOperators.indexOf(func as Operator) === -1\n      ) {\n        throw new Error(\n          `Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else {\n      throw new Error(\"Unknown comparator or operator\");\n    }\n    return `$${func}`;\n  }\n\n  /**\n   * Visits an operation and returns a result.\n   * @param operation The operation to visit.\n   * @returns The result of visiting the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const args = operation.args?.map((arg) =>\n      arg.accept(this)\n    ) as VisitorResult[];\n    return {\n      [this.formatFunction(operation.operator)]: args,\n    };\n  }\n\n  /**\n   * Visits a comparison and returns a result.\n   * @param comparison The comparison to visit.\n   * @returns The result of visiting the comparison.\n   */\n  visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"] {\n    return {\n      [comparison.attribute]: {\n        [this.formatFunction(comparison.comparator)]: castValue(\n          comparison.value\n        ),\n      },\n    };\n  }\n\n  /**\n   * Visits a structured query and returns a result.\n   * @param query The structured query to visit.\n   * @returns The result of visiting the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    let nextArg = {};\n    if (query.filter) {\n      nextArg = {\n        filter: query.filter.accept(this),\n      };\n    }\n    return nextArg;\n  }\n\n  mergeFilters(\n    defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    mergeType = \"and\",\n    forceDefaultFilter = false\n  ): VisitorStructuredQueryResult[\"filter\"] | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (forceDefaultFilter) {\n        return defaultFilter;\n      }\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n    if (mergeType === \"and\") {\n      return {\n        $and: [defaultFilter, generatedFilter],\n      };\n    } else if (mergeType === \"or\") {\n      return {\n        $or: [defaultFilter, generatedFilter],\n      };\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":";;;;;;;;AA+BA,IAAsB,iBAAtB,cAEUA,WAAAA,QAAW;;;;;;;;;AAiCrB,IAAa,kBAAb,cAEU,eAAkB;CAO1B;CAEA;CAEA,YAAY,MAAuB;AACjC,SAAO;AACP,OAAK,mBAAmB,MAAM,oBAAoB,CAChDC,WAAAA,UAAU,KACVA,WAAAA,UAAU,GACX;AACD,OAAK,qBAAqB,MAAM,sBAAsB;GACpDC,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACb;;CAGH,eAAe,MAAqC;AAClD,MAAI,QAAQA,WAAAA;OAER,KAAK,mBAAmB,SAAS,KACjC,KAAK,mBAAmB,QAAQ,KAAmB,KAAK,GAExD,OAAM,IAAI,MACR,cAAc,KAAK,qCAAqC,KAAK,mBAAmB,KAC9E,KACD,GACF;aAEM,QAAQD,WAAAA;OAEf,KAAK,iBAAiB,SAAS,KAC/B,KAAK,iBAAiB,QAAQ,KAAiB,KAAK,GAEpD,OAAM,IAAI,MACR,YAAY,KAAK,mCAAmC,KAAK,iBAAiB,KACxE,KACD,GACF;QAGH,OAAM,IAAI,MAAM,iCAAiC;AAEnD,SAAO,IAAI;;;;;;;CAQb,eAAe,WAAoD;EACjE,MAAM,OAAO,UAAU,MAAM,KAAK,QAChC,IAAI,OAAO,KAAK,CACjB;AACD,SAAO,GACJ,KAAK,eAAe,UAAU,SAAS,GAAG,MAC5C;;;;;;;CAQH,gBAAgB,YAAuD;AACrE,SAAO,GACJ,WAAW,YAAY,GACrB,KAAK,eAAe,WAAW,WAAW,GAAGE,cAAAA,UAC5C,WAAW,MACZ,EACF,EACF;;;;;;;CAQH,qBACE,OACoC;EACpC,IAAI,UAAU,EAAE;AAChB,MAAI,MAAM,OACR,WAAU,EACR,QAAQ,MAAM,OAAO,OAAO,KAAK,EAClC;AAEH,SAAO;;CAGT,aACE,eACA,iBACA,YAAY,OACZ,qBAAqB,OAC+B;AACpD,MAAIC,cAAAA,cAAc,cAAc,IAAIA,cAAAA,cAAc,gBAAgB,CAChE;AAEF,MAAIA,cAAAA,cAAc,cAAc,IAAI,cAAc,WAAW;AAC3D,OAAIA,cAAAA,cAAc,gBAAgB,CAChC;AAEF,UAAO;;AAET,MAAIA,cAAAA,cAAc,gBAAgB,EAAE;AAClC,OAAI,mBACF,QAAO;AAET,OAAI,cAAc,MAChB;AAEF,UAAO;;AAET,MAAI,cAAc,MAChB,QAAO,EACL,MAAM,CAAC,eAAe,gBAAgB,EACvC;WACQ,cAAc,KACvB,QAAO,EACL,KAAK,CAAC,eAAe,gBAAgB,EACtC;MAED,OAAM,IAAI,MAAM,qBAAqB"}
+{"version":3,"file":"base.cjs","names":["Visitor","Operators","Comparators","castValue","isFilterEmpty"],"sources":["../../src/structured_query/base.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n  Visitor,\n  VisitorComparisonResult,\n  VisitorOperationResult,\n  VisitorResult,\n  VisitorStructuredQueryResult,\n} from \"./ir.js\";\nimport { isFilterEmpty, castValue } from \"./utils.js\";\n\n/**\n * Options object for the BasicTranslator class. Specifies the allowed\n * operators and comparators.\n */\nexport type TranslatorOpts = {\n  allowedOperators: Operator[];\n  allowedComparators: Comparator[];\n};\n\n/**\n * Abstract class that provides a blueprint for creating specific\n * translator classes. Defines two abstract methods: formatFunction and\n * mergeFilters.\n */\nexport abstract class BaseTranslator<\n  T extends VectorStore = VectorStore,\n> extends Visitor<T> {\n  /**\n   * Formats a given function (either an operator or a comparator) into a\n   * string.\n   * @param func The function to format.\n   * @returns Formatted string representation of the function.\n   */\n  abstract formatFunction(func: Operator | Comparator): string;\n\n  /**\n   * Merges two filters into one, using a specified merge type.\n   * @param defaultFilter The default filter.\n   * @param generatedFilter The generated filter.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.\n   * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.\n   * @returns The merged filter, or undefined if both filters are empty.\n   */\n  abstract mergeFilters(\n    defaultFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    generatedFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    mergeType?: \"and\" | \"or\" | \"replace\",\n    forceDefaultFilter?: boolean\n  ): this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined;\n}\n\n/**\n * Class that extends the BaseTranslator class and provides concrete\n * implementations for the abstract methods. Also declares three types:\n * VisitOperationOutput, VisitComparisonOutput, and\n * VisitStructuredQueryOutput, which are used as the return types for the\n * visitOperation, visitComparison, and visitStructuredQuery methods\n * respectively.\n */\nexport class BasicTranslator<\n  T extends VectorStore = VectorStore,\n> extends BaseTranslator<T> {\n  declare VisitOperationOutput: VisitorOperationResult;\n\n  declare VisitComparisonOutput: VisitorComparisonResult;\n\n  declare VisitStructuredQueryOutput: VisitorStructuredQueryResult;\n\n  allowedOperators: Operator[];\n\n  allowedComparators: Comparator[];\n\n  constructor(opts?: TranslatorOpts) {\n    super();\n    this.allowedOperators = opts?.allowedOperators ?? [\n      Operators.and,\n      Operators.or,\n    ];\n    this.allowedComparators = opts?.allowedComparators ?? [\n      Comparators.eq,\n      Comparators.ne,\n      Comparators.gt,\n      Comparators.gte,\n      Comparators.lt,\n      Comparators.lte,\n    ];\n  }\n\n  formatFunction(func: Operator | Comparator): string {\n    if (func in Comparators) {\n      if (\n        this.allowedComparators.length > 0 &&\n        this.allowedComparators.indexOf(func as Comparator) === -1\n      ) {\n        throw new Error(\n          `Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else if (func in Operators) {\n      if (\n        this.allowedOperators.length > 0 &&\n        this.allowedOperators.indexOf(func as Operator) === -1\n      ) {\n        throw new Error(\n          `Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else {\n      throw new Error(\"Unknown comparator or operator\");\n    }\n    return `$${func}`;\n  }\n\n  /**\n   * Visits an operation and returns a result.\n   * @param operation The operation to visit.\n   * @returns The result of visiting the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const args = operation.args?.map((arg) =>\n      arg.accept(this)\n    ) as VisitorResult[];\n    return {\n      [this.formatFunction(operation.operator)]: args,\n    };\n  }\n\n  /**\n   * Visits a comparison and returns a result.\n   * @param comparison The comparison to visit.\n   * @returns The result of visiting the comparison.\n   */\n  visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"] {\n    return {\n      [comparison.attribute]: {\n        [this.formatFunction(comparison.comparator)]: castValue(\n          comparison.value\n        ),\n      },\n    };\n  }\n\n  /**\n   * Visits a structured query and returns a result.\n   * @param query The structured query to visit.\n   * @returns The result of visiting the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    let nextArg = {};\n    if (query.filter) {\n      nextArg = {\n        filter: query.filter.accept(this),\n      };\n    }\n    return nextArg;\n  }\n\n  mergeFilters(\n    defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    mergeType = \"and\",\n    forceDefaultFilter = false\n  ): VisitorStructuredQueryResult[\"filter\"] | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (forceDefaultFilter) {\n        return defaultFilter;\n      }\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n    if (mergeType === \"and\") {\n      return {\n        $and: [defaultFilter, generatedFilter],\n      };\n    } else if (mergeType === \"or\") {\n      return {\n        $or: [defaultFilter, generatedFilter],\n      };\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":";;;;;;;;AA+BA,IAAsB,iBAAtB,cAEUA,WAAAA,QAAW,CAuBrB;;;;;;;;;AAUA,IAAa,kBAAb,cAEU,eAAkB;CAO1B;CAEA;CAEA,YAAY,MAAuB;EACjC,MAAM;EACN,KAAK,mBAAmB,MAAM,oBAAoB,CAChDC,WAAAA,UAAU,KACVA,WAAAA,UAAU,EACZ;EACA,KAAK,qBAAqB,MAAM,sBAAsB;GACpDC,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACZA,WAAAA,YAAY;GACZA,WAAAA,YAAY;EACd;CACF;CAEA,eAAe,MAAqC;EAClD,IAAI,QAAQA,WAAAA,aAER;OAAA,KAAK,mBAAmB,SAAS,KACjC,KAAK,mBAAmB,QAAQ,IAAkB,MAAM,IAExD,MAAM,IAAI,MACR,cAAc,KAAK,qCAAqC,KAAK,mBAAmB,KAC9E,IACF,GACF;EAAA,OAEG,IAAI,QAAQD,WAAAA,WAEf;OAAA,KAAK,iBAAiB,SAAS,KAC/B,KAAK,iBAAiB,QAAQ,IAAgB,MAAM,IAEpD,MAAM,IAAI,MACR,YAAY,KAAK,mCAAmC,KAAK,iBAAiB,KACxE,IACF,GACF;EAAA,OAGF,MAAM,IAAI,MAAM,gCAAgC;EAElD,OAAO,IAAI;CACb;;;;;;CAOA,eAAe,WAAoD;EACjE,MAAM,OAAO,UAAU,MAAM,KAAK,QAChC,IAAI,OAAO,IAAI,CACjB;EACA,OAAO,GACJ,KAAK,eAAe,UAAU,QAAQ,IAAI,KAC7C;CACF;;;;;;CAOA,gBAAgB,YAAuD;EACrE,OAAO,GACJ,WAAW,YAAY,GACrB,KAAK,eAAe,WAAW,UAAU,IAAIE,cAAAA,UAC5C,WAAW,KACb,EACF,EACF;CACF;;;;;;CAOA,qBACE,OACoC;EACpC,IAAI,UAAU,CAAC;EACf,IAAI,MAAM,QACR,UAAU,EACR,QAAQ,MAAM,OAAO,OAAO,IAAI,EAClC;EAEF,OAAO;CACT;CAEA,aACE,eACA,iBACA,YAAY,OACZ,qBAAqB,OAC+B;EACpD,IAAIC,cAAAA,cAAc,aAAa,KAAKA,cAAAA,cAAc,eAAe,GAC/D;EAEF,IAAIA,cAAAA,cAAc,aAAa,KAAK,cAAc,WAAW;GAC3D,IAAIA,cAAAA,cAAc,eAAe,GAC/B;GAEF,OAAO;EACT;EACA,IAAIA,cAAAA,cAAc,eAAe,GAAG;GAClC,IAAI,oBACF,OAAO;GAET,IAAI,cAAc,OAChB;GAEF,OAAO;EACT;EACA,IAAI,cAAc,OAChB,OAAO,EACL,MAAM,CAAC,eAAe,eAAe,EACvC;OACK,IAAI,cAAc,MACvB,OAAO,EACL,KAAK,CAAC,eAAe,eAAe,EACtC;OAEA,MAAM,IAAI,MAAM,oBAAoB;CAExC;AACF"}

package/dist/structured_query/base.d.cts

@@ -1,6 +1,5 @@
 import { VectorStore } from "../vectorstores.cjs";
 import { Comparator, Comparison, Operation, Operator, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorStructuredQueryResult } from "./ir.cjs";
-
 //#region src/structured_query/base.d.ts
 /**
  * Options object for the BasicTranslator class. Specifies the allowed

package/dist/structured_query/base.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":[],"sources":["../../src/structured_query/base.ts"],"mappings":";;;;;;AAqBA;;KAAY,cAAA;EACV,gBAAA,EAAkB,QAAA;EAClB,kBAAA,EAAoB,UAAA;AAAA;;;;;AAQtB;uBAAsB,cAAA,WACV,WAAA,GAAc,WAAA,UAChB,OAAA,CAAQ,CAAA;EAFkB;;;;;;EAAA,SASzB,cAAA,CAAe,IAAA,EAAM,QAAA,GAAW,UAAA;EAP1B;;;;;;;;EAAA,SAiBN,YAAA,CACP,aAAA,4DACA,eAAA,4DACA,SAAA,6BACA,kBAAA;AAAA;;;;;;;;;cAYS,eAAA,WACD,WAAA,GAAc,WAAA,UAChB,cAAA,CAAe,CAAA;EACf,oBAAA,EAAsB,sBAAA;EAEtB,qBAAA,EAAuB,uBAAA;EAEvB,0BAAA,EAA4B,4BAAA;EAEpC,gBAAA,EAAkB,QAAA;EAElB,kBAAA,EAAoB,UAAA;EAEpB,WAAA,CAAY,IAAA,GAAO,cAAA;EAgBnB,cAAA,CAAe,IAAA,EAAM,QAAA,GAAW,UAAA;EAtBI;;;;;EAwDpC,cAAA,CAAe,SAAA,EAAW,SAAA;EAAA;;;;;EAc1B,eAAA,CAAgB,UAAA,EAAY,UAAA;EA3EpB;;;;;EA0FR,oBAAA,CACE,KAAA,EAAO,eAAA;EAWT,YAAA,CACE,aAAA,EAAe,4BAAA,wBACf,eAAA,EAAiB,4BAAA,wBACjB,SAAA,WACA,kBAAA,aACC,4BAAA;AAAA"}
+{"version":3,"file":"base.d.cts","names":[],"sources":["../../src/structured_query/base.ts"],"mappings":";;;;;;;KAqBY;EACV,kBAAkB;EAClB,oBAAoB;;;;;;;uBAQA,eACpB,UAAU,cAAc,qBAChB,QAAQ;;;;;;;WAOP,eAAe,MAAM,WAAW;;;;;;;;;WAUhC,aACP,yEACA,2EACA,sCACA;;;;;;;;;;cAYS,gBACX,UAAU,cAAc,qBAChB,eAAe;EACf,sBAAsB;EAEtB,uBAAuB;EAEvB,4BAA4B;EAEpC,kBAAkB;EAElB,oBAAoB;EAEpB,YAAY,OAAO;EAgBnB,eAAe,MAAM,WAAW;;;;;;EAkChC,eAAe,WAAW;;;;;;EAc1B,gBAAgB,YAAY;;;;;;EAe5B,qBACE,OAAO;EAWT,aACE,eAAe,oDACf,iBAAiB,oDACjB,oBACA,+BACC"}

package/dist/structured_query/base.d.ts

@@ -1,6 +1,5 @@
 import { VectorStore } from "../vectorstores.js";
 import { Comparator, Comparison, Operation, Operator, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorStructuredQueryResult } from "./ir.js";
-
 //#region src/structured_query/base.d.ts
 /**
  * Options object for the BasicTranslator class. Specifies the allowed

package/dist/structured_query/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":[],"sources":["../../src/structured_query/base.ts"],"mappings":";;;;;;AAqBA;;KAAY,cAAA;EACV,gBAAA,EAAkB,QAAA;EAClB,kBAAA,EAAoB,UAAA;AAAA;;;;;AAQtB;uBAAsB,cAAA,WACV,WAAA,GAAc,WAAA,UAChB,OAAA,CAAQ,CAAA;EAFkB;;;;;;EAAA,SASzB,cAAA,CAAe,IAAA,EAAM,QAAA,GAAW,UAAA;EAP1B;;;;;;;;EAAA,SAiBN,YAAA,CACP,aAAA,4DACA,eAAA,4DACA,SAAA,6BACA,kBAAA;AAAA;;;;;;;;;cAYS,eAAA,WACD,WAAA,GAAc,WAAA,UAChB,cAAA,CAAe,CAAA;EACf,oBAAA,EAAsB,sBAAA;EAEtB,qBAAA,EAAuB,uBAAA;EAEvB,0BAAA,EAA4B,4BAAA;EAEpC,gBAAA,EAAkB,QAAA;EAElB,kBAAA,EAAoB,UAAA;EAEpB,WAAA,CAAY,IAAA,GAAO,cAAA;EAgBnB,cAAA,CAAe,IAAA,EAAM,QAAA,GAAW,UAAA;EAtBI;;;;;EAwDpC,cAAA,CAAe,SAAA,EAAW,SAAA;EAAA;;;;;EAc1B,eAAA,CAAgB,UAAA,EAAY,UAAA;EA3EpB;;;;;EA0FR,oBAAA,CACE,KAAA,EAAO,eAAA;EAWT,YAAA,CACE,aAAA,EAAe,4BAAA,wBACf,eAAA,EAAiB,4BAAA,wBACjB,SAAA,WACA,kBAAA,aACC,4BAAA;AAAA"}
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../src/structured_query/base.ts"],"mappings":";;;;;;;KAqBY;EACV,kBAAkB;EAClB,oBAAoB;;;;;;;uBAQA,eACpB,UAAU,cAAc,qBAChB,QAAQ;;;;;;;WAOP,eAAe,MAAM,WAAW;;;;;;;;;WAUhC,aACP,yEACA,2EACA,sCACA;;;;;;;;;;cAYS,gBACX,UAAU,cAAc,qBAChB,eAAe;EACf,sBAAsB;EAEtB,uBAAuB;EAEvB,4BAA4B;EAEpC,kBAAkB;EAElB,oBAAoB;EAEpB,YAAY,OAAO;EAgBnB,eAAe,MAAM,WAAW;;;;;;EAkChC,eAAe,WAAW;;;;;;EAc1B,gBAAgB,YAAY;;;;;;EAe5B,qBACE,OAAO;EAWT,aACE,eAAe,oDACf,iBAAiB,oDACjB,oBACA,+BACC"}

package/dist/structured_query/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":[],"sources":["../../src/structured_query/base.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n  Visitor,\n  VisitorComparisonResult,\n  VisitorOperationResult,\n  VisitorResult,\n  VisitorStructuredQueryResult,\n} from \"./ir.js\";\nimport { isFilterEmpty, castValue } from \"./utils.js\";\n\n/**\n * Options object for the BasicTranslator class. Specifies the allowed\n * operators and comparators.\n */\nexport type TranslatorOpts = {\n  allowedOperators: Operator[];\n  allowedComparators: Comparator[];\n};\n\n/**\n * Abstract class that provides a blueprint for creating specific\n * translator classes. Defines two abstract methods: formatFunction and\n * mergeFilters.\n */\nexport abstract class BaseTranslator<\n  T extends VectorStore = VectorStore,\n> extends Visitor<T> {\n  /**\n   * Formats a given function (either an operator or a comparator) into a\n   * string.\n   * @param func The function to format.\n   * @returns Formatted string representation of the function.\n   */\n  abstract formatFunction(func: Operator | Comparator): string;\n\n  /**\n   * Merges two filters into one, using a specified merge type.\n   * @param defaultFilter The default filter.\n   * @param generatedFilter The generated filter.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.\n   * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.\n   * @returns The merged filter, or undefined if both filters are empty.\n   */\n  abstract mergeFilters(\n    defaultFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    generatedFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    mergeType?: \"and\" | \"or\" | \"replace\",\n    forceDefaultFilter?: boolean\n  ): this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined;\n}\n\n/**\n * Class that extends the BaseTranslator class and provides concrete\n * implementations for the abstract methods. Also declares three types:\n * VisitOperationOutput, VisitComparisonOutput, and\n * VisitStructuredQueryOutput, which are used as the return types for the\n * visitOperation, visitComparison, and visitStructuredQuery methods\n * respectively.\n */\nexport class BasicTranslator<\n  T extends VectorStore = VectorStore,\n> extends BaseTranslator<T> {\n  declare VisitOperationOutput: VisitorOperationResult;\n\n  declare VisitComparisonOutput: VisitorComparisonResult;\n\n  declare VisitStructuredQueryOutput: VisitorStructuredQueryResult;\n\n  allowedOperators: Operator[];\n\n  allowedComparators: Comparator[];\n\n  constructor(opts?: TranslatorOpts) {\n    super();\n    this.allowedOperators = opts?.allowedOperators ?? [\n      Operators.and,\n      Operators.or,\n    ];\n    this.allowedComparators = opts?.allowedComparators ?? [\n      Comparators.eq,\n      Comparators.ne,\n      Comparators.gt,\n      Comparators.gte,\n      Comparators.lt,\n      Comparators.lte,\n    ];\n  }\n\n  formatFunction(func: Operator | Comparator): string {\n    if (func in Comparators) {\n      if (\n        this.allowedComparators.length > 0 &&\n        this.allowedComparators.indexOf(func as Comparator) === -1\n      ) {\n        throw new Error(\n          `Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else if (func in Operators) {\n      if (\n        this.allowedOperators.length > 0 &&\n        this.allowedOperators.indexOf(func as Operator) === -1\n      ) {\n        throw new Error(\n          `Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else {\n      throw new Error(\"Unknown comparator or operator\");\n    }\n    return `$${func}`;\n  }\n\n  /**\n   * Visits an operation and returns a result.\n   * @param operation The operation to visit.\n   * @returns The result of visiting the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const args = operation.args?.map((arg) =>\n      arg.accept(this)\n    ) as VisitorResult[];\n    return {\n      [this.formatFunction(operation.operator)]: args,\n    };\n  }\n\n  /**\n   * Visits a comparison and returns a result.\n   * @param comparison The comparison to visit.\n   * @returns The result of visiting the comparison.\n   */\n  visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"] {\n    return {\n      [comparison.attribute]: {\n        [this.formatFunction(comparison.comparator)]: castValue(\n          comparison.value\n        ),\n      },\n    };\n  }\n\n  /**\n   * Visits a structured query and returns a result.\n   * @param query The structured query to visit.\n   * @returns The result of visiting the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    let nextArg = {};\n    if (query.filter) {\n      nextArg = {\n        filter: query.filter.accept(this),\n      };\n    }\n    return nextArg;\n  }\n\n  mergeFilters(\n    defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    mergeType = \"and\",\n    forceDefaultFilter = false\n  ): VisitorStructuredQueryResult[\"filter\"] | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (forceDefaultFilter) {\n        return defaultFilter;\n      }\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n    if (mergeType === \"and\") {\n      return {\n        $and: [defaultFilter, generatedFilter],\n      };\n    } else if (mergeType === \"or\") {\n      return {\n        $or: [defaultFilter, generatedFilter],\n      };\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":";;;;;;;;AA+BA,IAAsB,iBAAtB,cAEU,QAAW;;;;;;;;;AAiCrB,IAAa,kBAAb,cAEU,eAAkB;CAO1B;CAEA;CAEA,YAAY,MAAuB;AACjC,SAAO;AACP,OAAK,mBAAmB,MAAM,oBAAoB,CAChD,UAAU,KACV,UAAU,GACX;AACD,OAAK,qBAAqB,MAAM,sBAAsB;GACpD,YAAY;GACZ,YAAY;GACZ,YAAY;GACZ,YAAY;GACZ,YAAY;GACZ,YAAY;GACb;;CAGH,eAAe,MAAqC;AAClD,MAAI,QAAQ;OAER,KAAK,mBAAmB,SAAS,KACjC,KAAK,mBAAmB,QAAQ,KAAmB,KAAK,GAExD,OAAM,IAAI,MACR,cAAc,KAAK,qCAAqC,KAAK,mBAAmB,KAC9E,KACD,GACF;aAEM,QAAQ;OAEf,KAAK,iBAAiB,SAAS,KAC/B,KAAK,iBAAiB,QAAQ,KAAiB,KAAK,GAEpD,OAAM,IAAI,MACR,YAAY,KAAK,mCAAmC,KAAK,iBAAiB,KACxE,KACD,GACF;QAGH,OAAM,IAAI,MAAM,iCAAiC;AAEnD,SAAO,IAAI;;;;;;;CAQb,eAAe,WAAoD;EACjE,MAAM,OAAO,UAAU,MAAM,KAAK,QAChC,IAAI,OAAO,KAAK,CACjB;AACD,SAAO,GACJ,KAAK,eAAe,UAAU,SAAS,GAAG,MAC5C;;;;;;;CAQH,gBAAgB,YAAuD;AACrE,SAAO,GACJ,WAAW,YAAY,GACrB,KAAK,eAAe,WAAW,WAAW,GAAG,UAC5C,WAAW,MACZ,EACF,EACF;;;;;;;CAQH,qBACE,OACoC;EACpC,IAAI,UAAU,EAAE;AAChB,MAAI,MAAM,OACR,WAAU,EACR,QAAQ,MAAM,OAAO,OAAO,KAAK,EAClC;AAEH,SAAO;;CAGT,aACE,eACA,iBACA,YAAY,OACZ,qBAAqB,OAC+B;AACpD,MAAI,cAAc,cAAc,IAAI,cAAc,gBAAgB,CAChE;AAEF,MAAI,cAAc,cAAc,IAAI,cAAc,WAAW;AAC3D,OAAI,cAAc,gBAAgB,CAChC;AAEF,UAAO;;AAET,MAAI,cAAc,gBAAgB,EAAE;AAClC,OAAI,mBACF,QAAO;AAET,OAAI,cAAc,MAChB;AAEF,UAAO;;AAET,MAAI,cAAc,MAChB,QAAO,EACL,MAAM,CAAC,eAAe,gBAAgB,EACvC;WACQ,cAAc,KACvB,QAAO,EACL,KAAK,CAAC,eAAe,gBAAgB,EACtC;MAED,OAAM,IAAI,MAAM,qBAAqB"}
+{"version":3,"file":"base.js","names":[],"sources":["../../src/structured_query/base.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n  Visitor,\n  VisitorComparisonResult,\n  VisitorOperationResult,\n  VisitorResult,\n  VisitorStructuredQueryResult,\n} from \"./ir.js\";\nimport { isFilterEmpty, castValue } from \"./utils.js\";\n\n/**\n * Options object for the BasicTranslator class. Specifies the allowed\n * operators and comparators.\n */\nexport type TranslatorOpts = {\n  allowedOperators: Operator[];\n  allowedComparators: Comparator[];\n};\n\n/**\n * Abstract class that provides a blueprint for creating specific\n * translator classes. Defines two abstract methods: formatFunction and\n * mergeFilters.\n */\nexport abstract class BaseTranslator<\n  T extends VectorStore = VectorStore,\n> extends Visitor<T> {\n  /**\n   * Formats a given function (either an operator or a comparator) into a\n   * string.\n   * @param func The function to format.\n   * @returns Formatted string representation of the function.\n   */\n  abstract formatFunction(func: Operator | Comparator): string;\n\n  /**\n   * Merges two filters into one, using a specified merge type.\n   * @param defaultFilter The default filter.\n   * @param generatedFilter The generated filter.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.\n   * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.\n   * @returns The merged filter, or undefined if both filters are empty.\n   */\n  abstract mergeFilters(\n    defaultFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    generatedFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined,\n    mergeType?: \"and\" | \"or\" | \"replace\",\n    forceDefaultFilter?: boolean\n  ): this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined;\n}\n\n/**\n * Class that extends the BaseTranslator class and provides concrete\n * implementations for the abstract methods. Also declares three types:\n * VisitOperationOutput, VisitComparisonOutput, and\n * VisitStructuredQueryOutput, which are used as the return types for the\n * visitOperation, visitComparison, and visitStructuredQuery methods\n * respectively.\n */\nexport class BasicTranslator<\n  T extends VectorStore = VectorStore,\n> extends BaseTranslator<T> {\n  declare VisitOperationOutput: VisitorOperationResult;\n\n  declare VisitComparisonOutput: VisitorComparisonResult;\n\n  declare VisitStructuredQueryOutput: VisitorStructuredQueryResult;\n\n  allowedOperators: Operator[];\n\n  allowedComparators: Comparator[];\n\n  constructor(opts?: TranslatorOpts) {\n    super();\n    this.allowedOperators = opts?.allowedOperators ?? [\n      Operators.and,\n      Operators.or,\n    ];\n    this.allowedComparators = opts?.allowedComparators ?? [\n      Comparators.eq,\n      Comparators.ne,\n      Comparators.gt,\n      Comparators.gte,\n      Comparators.lt,\n      Comparators.lte,\n    ];\n  }\n\n  formatFunction(func: Operator | Comparator): string {\n    if (func in Comparators) {\n      if (\n        this.allowedComparators.length > 0 &&\n        this.allowedComparators.indexOf(func as Comparator) === -1\n      ) {\n        throw new Error(\n          `Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else if (func in Operators) {\n      if (\n        this.allowedOperators.length > 0 &&\n        this.allowedOperators.indexOf(func as Operator) === -1\n      ) {\n        throw new Error(\n          `Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(\n            \", \"\n          )}`\n        );\n      }\n    } else {\n      throw new Error(\"Unknown comparator or operator\");\n    }\n    return `$${func}`;\n  }\n\n  /**\n   * Visits an operation and returns a result.\n   * @param operation The operation to visit.\n   * @returns The result of visiting the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const args = operation.args?.map((arg) =>\n      arg.accept(this)\n    ) as VisitorResult[];\n    return {\n      [this.formatFunction(operation.operator)]: args,\n    };\n  }\n\n  /**\n   * Visits a comparison and returns a result.\n   * @param comparison The comparison to visit.\n   * @returns The result of visiting the comparison.\n   */\n  visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"] {\n    return {\n      [comparison.attribute]: {\n        [this.formatFunction(comparison.comparator)]: castValue(\n          comparison.value\n        ),\n      },\n    };\n  }\n\n  /**\n   * Visits a structured query and returns a result.\n   * @param query The structured query to visit.\n   * @returns The result of visiting the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    let nextArg = {};\n    if (query.filter) {\n      nextArg = {\n        filter: query.filter.accept(this),\n      };\n    }\n    return nextArg;\n  }\n\n  mergeFilters(\n    defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined,\n    mergeType = \"and\",\n    forceDefaultFilter = false\n  ): VisitorStructuredQueryResult[\"filter\"] | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (forceDefaultFilter) {\n        return defaultFilter;\n      }\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n    if (mergeType === \"and\") {\n      return {\n        $and: [defaultFilter, generatedFilter],\n      };\n    } else if (mergeType === \"or\") {\n      return {\n        $or: [defaultFilter, generatedFilter],\n      };\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":";;;;;;;;AA+BA,IAAsB,iBAAtB,cAEU,QAAW,CAuBrB;;;;;;;;;AAUA,IAAa,kBAAb,cAEU,eAAkB;CAO1B;CAEA;CAEA,YAAY,MAAuB;EACjC,MAAM;EACN,KAAK,mBAAmB,MAAM,oBAAoB,CAChD,UAAU,KACV,UAAU,EACZ;EACA,KAAK,qBAAqB,MAAM,sBAAsB;GACpD,YAAY;GACZ,YAAY;GACZ,YAAY;GACZ,YAAY;GACZ,YAAY;GACZ,YAAY;EACd;CACF;CAEA,eAAe,MAAqC;EAClD,IAAI,QAAQ,aAER;OAAA,KAAK,mBAAmB,SAAS,KACjC,KAAK,mBAAmB,QAAQ,IAAkB,MAAM,IAExD,MAAM,IAAI,MACR,cAAc,KAAK,qCAAqC,KAAK,mBAAmB,KAC9E,IACF,GACF;EAAA,OAEG,IAAI,QAAQ,WAEf;OAAA,KAAK,iBAAiB,SAAS,KAC/B,KAAK,iBAAiB,QAAQ,IAAgB,MAAM,IAEpD,MAAM,IAAI,MACR,YAAY,KAAK,mCAAmC,KAAK,iBAAiB,KACxE,IACF,GACF;EAAA,OAGF,MAAM,IAAI,MAAM,gCAAgC;EAElD,OAAO,IAAI;CACb;;;;;;CAOA,eAAe,WAAoD;EACjE,MAAM,OAAO,UAAU,MAAM,KAAK,QAChC,IAAI,OAAO,IAAI,CACjB;EACA,OAAO,GACJ,KAAK,eAAe,UAAU,QAAQ,IAAI,KAC7C;CACF;;;;;;CAOA,gBAAgB,YAAuD;EACrE,OAAO,GACJ,WAAW,YAAY,GACrB,KAAK,eAAe,WAAW,UAAU,IAAI,UAC5C,WAAW,KACb,EACF,EACF;CACF;;;;;;CAOA,qBACE,OACoC;EACpC,IAAI,UAAU,CAAC;EACf,IAAI,MAAM,QACR,UAAU,EACR,QAAQ,MAAM,OAAO,OAAO,IAAI,EAClC;EAEF,OAAO;CACT;CAEA,aACE,eACA,iBACA,YAAY,OACZ,qBAAqB,OAC+B;EACpD,IAAI,cAAc,aAAa,KAAK,cAAc,eAAe,GAC/D;EAEF,IAAI,cAAc,aAAa,KAAK,cAAc,WAAW;GAC3D,IAAI,cAAc,eAAe,GAC/B;GAEF,OAAO;EACT;EACA,IAAI,cAAc,eAAe,GAAG;GAClC,IAAI,oBACF,OAAO;GAET,IAAI,cAAc,OAChB;GAEF,OAAO;EACT;EACA,IAAI,cAAc,OAChB,OAAO,EACL,MAAM,CAAC,eAAe,eAAe,EACvC;OACK,IAAI,cAAc,MACvB,OAAO,EACL,KAAK,CAAC,eAAe,eAAe,EACtC;OAEA,MAAM,IAAI,MAAM,oBAAoB;CAExC;AACF"}

package/dist/structured_query/functional.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"functional.cjs","names":["BaseTranslator","Operators","Comparators","castValue","isFilterEmpty"],"sources":["../../src/structured_query/functional.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n} from \"./ir.js\";\nimport { BaseTranslator } from \"./base.js\";\nimport { castValue, isFilterEmpty } from \"./utils.js\";\n\n/**\n * A type alias for an object that maps comparison operators to string or\n * number values. This is used in the comparison functions to determine\n * the result of a comparison operation.\n */\ntype ValueType = {\n  eq: string | number | boolean;\n  ne: string | number | boolean;\n  lt: string | number;\n  lte: string | number;\n  gt: string | number;\n  gte: string | number;\n};\n\n/**\n * A type alias for a function that takes a `Document` as an argument and\n * returns a boolean. This function is used as a filter for documents.\n */\nexport type FunctionFilter = (document: Document) => boolean;\n\n/**\n * A class that extends `BaseTranslator` to translate structured queries\n * into functional filters.\n * @example\n * ```typescript\n * const functionalTranslator = new FunctionalTranslator();\n * const relevantDocuments = await functionalTranslator.getRelevantDocuments(\n *   \"Which movies are rated higher than 8.5?\",\n * );\n * ```\n */\nexport class FunctionalTranslator extends BaseTranslator {\n  declare VisitOperationOutput: FunctionFilter;\n\n  declare VisitComparisonOutput: FunctionFilter;\n\n  declare VisitStructuredQueryOutput:\n    | { filter: FunctionFilter }\n    | { [k: string]: never };\n\n  allowedOperators: Operator[] = [Operators.and, Operators.or];\n\n  allowedComparators: Comparator[] = [\n    Comparators.eq,\n    Comparators.ne,\n    Comparators.gt,\n    Comparators.gte,\n    Comparators.lt,\n    Comparators.lte,\n  ];\n\n  formatFunction(): string {\n    throw new Error(\"Not implemented\");\n  }\n\n  /**\n   * Returns the allowed comparators for a given data type.\n   * @param input The input value to get the allowed comparators for.\n   * @returns An array of allowed comparators for the input data type.\n   */\n  getAllowedComparatorsForType(inputType: string): Comparator[] {\n    switch (inputType) {\n      case \"string\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"number\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"boolean\": {\n        return [Comparators.eq, Comparators.ne];\n      }\n      default: {\n        throw new Error(`Unsupported data type: ${inputType}`);\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs a comparison based on the provided\n   * comparator.\n   * @param comparator The comparator to base the comparison function on.\n   * @returns A function that takes two arguments and returns a boolean based on the comparison.\n   */\n  getComparatorFunction<C extends Comparator>(\n    comparator: Comparator\n  ): (a: string | number, b: ValueType[C]) => boolean {\n    switch (comparator) {\n      case Comparators.eq: {\n        return (a: string | number, b: ValueType[C]) => a === b;\n      }\n      case Comparators.ne: {\n        return (a: string | number, b: ValueType[C]) => a !== b;\n      }\n      case Comparators.gt: {\n        return (a: string | number, b: ValueType[C]) => a > b;\n      }\n      case Comparators.gte: {\n        return (a: string | number, b: ValueType[C]) => a >= b;\n      }\n      case Comparators.lt: {\n        return (a: string | number, b: ValueType[C]) => a < b;\n      }\n      case Comparators.lte: {\n        return (a: string | number, b: ValueType[C]) => a <= b;\n      }\n      default: {\n        throw new Error(\"Unknown comparator\");\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs an operation based on the provided\n   * operator.\n   * @param operator The operator to base the operation function on.\n   * @returns A function that takes two boolean arguments and returns a boolean based on the operation.\n   */\n  getOperatorFunction(operator: Operator): (a: boolean, b: boolean) => boolean {\n    switch (operator) {\n      case Operators.and: {\n        return (a, b) => a && b;\n      }\n      case Operators.or: {\n        return (a, b) => a || b;\n      }\n      default: {\n        throw new Error(\"Unknown operator\");\n      }\n    }\n  }\n\n  /**\n   * Visits the operation part of a structured query and translates it into\n   * a functional filter.\n   * @param operation The operation part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const { operator, args } = operation;\n    if (this.allowedOperators.includes(operator)) {\n      const operatorFunction = this.getOperatorFunction(operator);\n      return (document: Document) => {\n        if (!args) {\n          return true;\n        }\n\n        return args.reduce((acc, arg) => {\n          const result = arg.accept(this);\n          if (typeof result === \"function\") {\n            return operatorFunction(acc, result(document));\n          } else {\n            throw new Error(\"Filter is not a function\");\n          }\n        }, true);\n      };\n    } else {\n      throw new Error(\"Operator not allowed\");\n    }\n  }\n\n  /**\n   * Visits the comparison part of a structured query and translates it into\n   * a functional filter.\n   * @param comparison The comparison part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.\n   */\n  visitComparison(\n    comparison: Comparison<string | number | boolean>\n  ): this[\"VisitComparisonOutput\"] {\n    const { comparator, attribute, value } = comparison;\n    const undefinedTrue = [Comparators.ne];\n    if (this.allowedComparators.includes(comparator)) {\n      if (\n        !this.getAllowedComparatorsForType(typeof value).includes(comparator)\n      ) {\n        throw new Error(\n          `'${comparator}' comparator not allowed to be used with ${typeof value}`\n        );\n      }\n      const comparatorFunction = this.getComparatorFunction(comparator);\n      return (document: Document) => {\n        const documentValue = document.metadata[attribute];\n        if (documentValue === undefined) {\n          if (undefinedTrue.includes(comparator)) {\n            return true;\n          }\n          return false;\n        }\n        return comparatorFunction(documentValue, castValue(value));\n      };\n    } else {\n      throw new Error(\"Comparator not allowed\");\n    }\n  }\n\n  /**\n   * Visits a structured query and translates it into a functional filter.\n   * @param query The structured query to translate.\n   * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    if (!query.filter) {\n      return {};\n    }\n    const filterFunction = query.filter?.accept(this);\n    if (typeof filterFunction !== \"function\") {\n      throw new Error(\"Structured query filter is not a function\");\n    }\n    return { filter: filterFunction as FunctionFilter };\n  }\n\n  /**\n   * Merges two filters into one, based on the specified merge type.\n   * @param defaultFilter The default filter function.\n   * @param generatedFilter The generated filter function.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.\n   */\n  mergeFilters(\n    defaultFilter: FunctionFilter,\n    generatedFilter: FunctionFilter,\n    mergeType = \"and\"\n  ): FunctionFilter | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n\n    if (mergeType === \"and\") {\n      return (document: Document) =>\n        defaultFilter(document) && generatedFilter(document);\n    } else if (mergeType === \"or\") {\n      return (document: Document) =>\n        defaultFilter(document) || generatedFilter(document);\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"functional.cjs","names":["BaseTranslator","Operators","Comparators","castValue","isFilterEmpty"],"sources":["../../src/structured_query/functional.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n} from \"./ir.js\";\nimport { BaseTranslator } from \"./base.js\";\nimport { castValue, isFilterEmpty } from \"./utils.js\";\n\n/**\n * A type alias for an object that maps comparison operators to string or\n * number values. This is used in the comparison functions to determine\n * the result of a comparison operation.\n */\ntype ValueType = {\n  eq: string | number | boolean;\n  ne: string | number | boolean;\n  lt: string | number;\n  lte: string | number;\n  gt: string | number;\n  gte: string | number;\n};\n\n/**\n * A type alias for a function that takes a `Document` as an argument and\n * returns a boolean. This function is used as a filter for documents.\n */\nexport type FunctionFilter = (document: Document) => boolean;\n\n/**\n * A class that extends `BaseTranslator` to translate structured queries\n * into functional filters.\n * @example\n * ```typescript\n * const functionalTranslator = new FunctionalTranslator();\n * const relevantDocuments = await functionalTranslator.getRelevantDocuments(\n *   \"Which movies are rated higher than 8.5?\",\n * );\n * ```\n */\nexport class FunctionalTranslator extends BaseTranslator {\n  declare VisitOperationOutput: FunctionFilter;\n\n  declare VisitComparisonOutput: FunctionFilter;\n\n  declare VisitStructuredQueryOutput:\n    | { filter: FunctionFilter }\n    | { [k: string]: never };\n\n  allowedOperators: Operator[] = [Operators.and, Operators.or];\n\n  allowedComparators: Comparator[] = [\n    Comparators.eq,\n    Comparators.ne,\n    Comparators.gt,\n    Comparators.gte,\n    Comparators.lt,\n    Comparators.lte,\n  ];\n\n  formatFunction(): string {\n    throw new Error(\"Not implemented\");\n  }\n\n  /**\n   * Returns the allowed comparators for a given data type.\n   * @param input The input value to get the allowed comparators for.\n   * @returns An array of allowed comparators for the input data type.\n   */\n  getAllowedComparatorsForType(inputType: string): Comparator[] {\n    switch (inputType) {\n      case \"string\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"number\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"boolean\": {\n        return [Comparators.eq, Comparators.ne];\n      }\n      default: {\n        throw new Error(`Unsupported data type: ${inputType}`);\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs a comparison based on the provided\n   * comparator.\n   * @param comparator The comparator to base the comparison function on.\n   * @returns A function that takes two arguments and returns a boolean based on the comparison.\n   */\n  getComparatorFunction<C extends Comparator>(\n    comparator: Comparator\n  ): (a: string | number, b: ValueType[C]) => boolean {\n    switch (comparator) {\n      case Comparators.eq: {\n        return (a: string | number, b: ValueType[C]) => a === b;\n      }\n      case Comparators.ne: {\n        return (a: string | number, b: ValueType[C]) => a !== b;\n      }\n      case Comparators.gt: {\n        return (a: string | number, b: ValueType[C]) => a > b;\n      }\n      case Comparators.gte: {\n        return (a: string | number, b: ValueType[C]) => a >= b;\n      }\n      case Comparators.lt: {\n        return (a: string | number, b: ValueType[C]) => a < b;\n      }\n      case Comparators.lte: {\n        return (a: string | number, b: ValueType[C]) => a <= b;\n      }\n      default: {\n        throw new Error(\"Unknown comparator\");\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs an operation based on the provided\n   * operator.\n   * @param operator The operator to base the operation function on.\n   * @returns A function that takes two boolean arguments and returns a boolean based on the operation.\n   */\n  getOperatorFunction(operator: Operator): (a: boolean, b: boolean) => boolean {\n    switch (operator) {\n      case Operators.and: {\n        return (a, b) => a && b;\n      }\n      case Operators.or: {\n        return (a, b) => a || b;\n      }\n      default: {\n        throw new Error(\"Unknown operator\");\n      }\n    }\n  }\n\n  /**\n   * Visits the operation part of a structured query and translates it into\n   * a functional filter.\n   * @param operation The operation part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const { operator, args } = operation;\n    if (this.allowedOperators.includes(operator)) {\n      const operatorFunction = this.getOperatorFunction(operator);\n      return (document: Document) => {\n        if (!args) {\n          return true;\n        }\n\n        return args.reduce((acc, arg) => {\n          const result = arg.accept(this);\n          if (typeof result === \"function\") {\n            return operatorFunction(acc, result(document));\n          } else {\n            throw new Error(\"Filter is not a function\");\n          }\n        }, true);\n      };\n    } else {\n      throw new Error(\"Operator not allowed\");\n    }\n  }\n\n  /**\n   * Visits the comparison part of a structured query and translates it into\n   * a functional filter.\n   * @param comparison The comparison part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.\n   */\n  visitComparison(\n    comparison: Comparison<string | number | boolean>\n  ): this[\"VisitComparisonOutput\"] {\n    const { comparator, attribute, value } = comparison;\n    const undefinedTrue = [Comparators.ne];\n    if (this.allowedComparators.includes(comparator)) {\n      if (\n        !this.getAllowedComparatorsForType(typeof value).includes(comparator)\n      ) {\n        throw new Error(\n          `'${comparator}' comparator not allowed to be used with ${typeof value}`\n        );\n      }\n      const comparatorFunction = this.getComparatorFunction(comparator);\n      return (document: Document) => {\n        const documentValue = document.metadata[attribute];\n        if (documentValue === undefined) {\n          if (undefinedTrue.includes(comparator)) {\n            return true;\n          }\n          return false;\n        }\n        return comparatorFunction(documentValue, castValue(value));\n      };\n    } else {\n      throw new Error(\"Comparator not allowed\");\n    }\n  }\n\n  /**\n   * Visits a structured query and translates it into a functional filter.\n   * @param query The structured query to translate.\n   * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    if (!query.filter) {\n      return {};\n    }\n    const filterFunction = query.filter?.accept(this);\n    if (typeof filterFunction !== \"function\") {\n      throw new Error(\"Structured query filter is not a function\");\n    }\n    return { filter: filterFunction as FunctionFilter };\n  }\n\n  /**\n   * Merges two filters into one, based on the specified merge type.\n   * @param defaultFilter The default filter function.\n   * @param generatedFilter The generated filter function.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.\n   */\n  mergeFilters(\n    defaultFilter: FunctionFilter,\n    generatedFilter: FunctionFilter,\n    mergeType = \"and\"\n  ): FunctionFilter | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n\n    if (mergeType === \"and\") {\n      return (document: Document) =>\n        defaultFilter(document) && generatedFilter(document);\n    } else if (mergeType === \"or\") {\n      return (document: Document) =>\n        defaultFilter(document) || generatedFilter(document);\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AA4CA,IAAa,uBAAb,cAA0CA,aAAAA,eAAe;CASvD,mBAA+B,CAACC,WAAAA,UAAU,KAAKA,WAAAA,UAAU,EAAE;CAE3D,qBAAmC;EACjCC,WAAAA,YAAY;EACZA,WAAAA,YAAY;EACZA,WAAAA,YAAY;EACZA,WAAAA,YAAY;EACZA,WAAAA,YAAY;EACZA,WAAAA,YAAY;CACd;CAEA,iBAAyB;EACvB,MAAM,IAAI,MAAM,iBAAiB;CACnC;;;;;;CAOA,6BAA6B,WAAiC;EAC5D,QAAQ,WAAR;GACE,KAAK,UACH,OAAO;IACLA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;GACd;GAEF,KAAK,UACH,OAAO;IACLA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;IACZA,WAAAA,YAAY;GACd;GAEF,KAAK,WACH,OAAO,CAACA,WAAAA,YAAY,IAAIA,WAAAA,YAAY,EAAE;GAExC,SACE,MAAM,IAAI,MAAM,0BAA0B,WAAW;EAEzD;CACF;;;;;;;CAQA,sBACE,YACkD;EAClD,QAAQ,YAAR;GACE,KAAKA,WAAAA,YAAY,IACf,QAAQ,GAAoB,MAAoB,MAAM;GAExD,KAAKA,WAAAA,YAAY,IACf,QAAQ,GAAoB,MAAoB,MAAM;GAExD,KAAKA,WAAAA,YAAY,IACf,QAAQ,GAAoB,MAAoB,IAAI;GAEtD,KAAKA,WAAAA,YAAY,KACf,QAAQ,GAAoB,MAAoB,KAAK;GAEvD,KAAKA,WAAAA,YAAY,IACf,QAAQ,GAAoB,MAAoB,IAAI;GAEtD,KAAKA,WAAAA,YAAY,KACf,QAAQ,GAAoB,MAAoB,KAAK;GAEvD,SACE,MAAM,IAAI,MAAM,oBAAoB;EAExC;CACF;;;;;;;CAQA,oBAAoB,UAAyD;EAC3E,QAAQ,UAAR;GACE,KAAKD,WAAAA,UAAU,KACb,QAAQ,GAAG,MAAM,KAAK;GAExB,KAAKA,WAAAA,UAAU,IACb,QAAQ,GAAG,MAAM,KAAK;GAExB,SACE,MAAM,IAAI,MAAM,kBAAkB;EAEtC;CACF;;;;;;;CAQA,eAAe,WAAoD;EACjE,MAAM,EAAE,UAAU,SAAS;EAC3B,IAAI,KAAK,iBAAiB,SAAS,QAAQ,GAAG;GAC5C,MAAM,mBAAmB,KAAK,oBAAoB,QAAQ;GAC1D,QAAQ,aAAuB;IAC7B,IAAI,CAAC,MACH,OAAO;IAGT,OAAO,KAAK,QAAQ,KAAK,QAAQ;KAC/B,MAAM,SAAS,IAAI,OAAO,IAAI;KAC9B,IAAI,OAAO,WAAW,YACpB,OAAO,iBAAiB,KAAK,OAAO,QAAQ,CAAC;UAE7C,MAAM,IAAI,MAAM,0BAA0B;IAE9C,GAAG,IAAI;GACT;EACF,OACE,MAAM,IAAI,MAAM,sBAAsB;CAE1C;;;;;;;CAQA,gBACE,YAC+B;EAC/B,MAAM,EAAE,YAAY,WAAW,UAAU;EACzC,MAAM,gBAAgB,CAACC,WAAAA,YAAY,EAAE;EACrC,IAAI,KAAK,mBAAmB,SAAS,UAAU,GAAG;GAChD,IACE,CAAC,KAAK,6BAA6B,OAAO,KAAK,CAAC,CAAC,SAAS,UAAU,GAEpE,MAAM,IAAI,MACR,IAAI,WAAW,2CAA2C,OAAO,OACnE;GAEF,MAAM,qBAAqB,KAAK,sBAAsB,UAAU;GAChE,QAAQ,aAAuB;IAC7B,MAAM,gBAAgB,SAAS,SAAS;IACxC,IAAI,kBAAkB,KAAA,GAAW;KAC/B,IAAI,cAAc,SAAS,UAAU,GACnC,OAAO;KAET,OAAO;IACT;IACA,OAAO,mBAAmB,eAAeC,cAAAA,UAAU,KAAK,CAAC;GAC3D;EACF,OACE,MAAM,IAAI,MAAM,wBAAwB;CAE5C;;;;;;CAOA,qBACE,OACoC;EACpC,IAAI,CAAC,MAAM,QACT,OAAO,CAAC;EAEV,MAAM,iBAAiB,MAAM,QAAQ,OAAO,IAAI;EAChD,IAAI,OAAO,mBAAmB,YAC5B,MAAM,IAAI,MAAM,2CAA2C;EAE7D,OAAO,EAAE,QAAQ,eAAiC;CACpD;;;;;;;;CASA,aACE,eACA,iBACA,YAAY,OACgB;EAC5B,IAAIC,cAAAA,cAAc,aAAa,KAAKA,cAAAA,cAAc,eAAe,GAC/D;EAEF,IAAIA,cAAAA,cAAc,aAAa,KAAK,cAAc,WAAW;GAC3D,IAAIA,cAAAA,cAAc,eAAe,GAC/B;GAEF,OAAO;EACT;EACA,IAAIA,cAAAA,cAAc,eAAe,GAAG;GAClC,IAAI,cAAc,OAChB;GAEF,OAAO;EACT;EAEA,IAAI,cAAc,OAChB,QAAQ,aACN,cAAc,QAAQ,KAAK,gBAAgB,QAAQ;OAChD,IAAI,cAAc,MACvB,QAAQ,aACN,cAAc,QAAQ,KAAK,gBAAgB,QAAQ;OAErD,MAAM,IAAI,MAAM,oBAAoB;CAExC;AACF"}

package/dist/structured_query/functional.d.cts

@@ -1,7 +1,6 @@
 import { Document } from "../documents/document.cjs";
 import { Comparator, Comparison, Operation, Operator, StructuredQuery } from "./ir.cjs";
 import { BaseTranslator } from "./base.cjs";
-
 //#region src/structured_query/functional.d.ts
 /**
  * A type alias for an object that maps comparison operators to string or

package/dist/structured_query/functional.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"functional.d.cts","names":[],"sources":["../../src/structured_query/functional.ts"],"mappings":";;;;;;;AAU2C;;;KAQtC,SAAA;EACH,EAAA;EACA,EAAA;EACA,EAAA;EACA,GAAA;EACA,EAAA;EACA,GAAA;AAAA;;AAOF;;;KAAY,cAAA,IAAkB,QAAA,EAAU,QAAA;;AAaxC;;;;;;;;;;cAAa,oBAAA,SAA6B,cAAA;EAChC,oBAAA,EAAsB,cAAA;EAEtB,qBAAA,EAAuB,cAAA;EAEvB,0BAAA;IACF,MAAA,EAAQ,cAAA;EAAA;IAAA,CACP,CAAA;EAAA;EAEP,gBAAA,EAAkB,QAAA;EAElB,kBAAA,EAAoB,UAAA;EASpB,cAAA,CAAA;EApBsD;;;;;EA6BtD,4BAAA,CAA6B,SAAA,WAAoB,UAAA;EA1BlB;;;;;;EA+D/B,qBAAA,WAAgC,UAAA,CAAA,CAC9B,UAAA,EAAY,UAAA,IACV,CAAA,mBAAoB,CAAA,EAAG,SAAA,CAAU,CAAA;EAzDrC;;;;;;EAyFA,mBAAA,CAAoB,QAAA,EAAU,QAAA,IAAY,CAAA,WAAY,CAAA;EAlChC;;;;;;EAsDtB,cAAA,CAAe,SAAA,EAAW,SAAA;EApDF;;;;;;EAiFxB,eAAA,CACE,UAAA,EAAY,UAAA;EA9BY;;;;;EA+D1B,oBAAA,CACE,KAAA,EAAO,eAAA;EAAA;;;;;;;EAmBT,YAAA,CACE,aAAA,EAAe,cAAA,EACf,eAAA,EAAiB,cAAA,EACjB,SAAA,YACC,cAAA;AAAA"}
+{"version":3,"file":"functional.d.cts","names":[],"sources":["../../src/structured_query/functional.ts"],"mappings":";;;;;;;;;KAkBK;EACH;EACA;EACA;EACA;EACA;EACA;;;;;;KAOU,kBAAkB,UAAU;;;;;;;;;;;;cAa3B,6BAA6B;EAChC,sBAAsB;EAEtB,uBAAuB;EAEvB;IACF,QAAQ;;KACP;;EAEP,kBAAkB;EAElB,oBAAoB;EASpB;;;;;;EASA,6BAA6B,oBAAoB;;;;;;;EAqCjD,sBAAsB,UAAU,YAC9B,YAAY,cACV,oBAAoB,GAAG,UAAU;;;;;;;EAgCrC,oBAAoB,UAAU,YAAY,YAAY;;;;;;;EAoBtD,eAAe,WAAW;;;;;;;EA6B1B,gBACE,YAAY;;;;;;EAiCd,qBACE,OAAO;;;;;;;;EAmBT,aACE,eAAe,gBACf,iBAAiB,gBACjB,qBACC"}

package/dist/structured_query/functional.d.ts

@@ -1,7 +1,6 @@
 import { Document } from "../documents/document.js";
 import { Comparator, Comparison, Operation, Operator, StructuredQuery } from "./ir.js";
 import { BaseTranslator } from "./base.js";
-
 //#region src/structured_query/functional.d.ts
 /**
  * A type alias for an object that maps comparison operators to string or

package/dist/structured_query/functional.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functional.d.ts","names":[],"sources":["../../src/structured_query/functional.ts"],"mappings":";;;;;;;AAU2C;;;KAQtC,SAAA;EACH,EAAA;EACA,EAAA;EACA,EAAA;EACA,GAAA;EACA,EAAA;EACA,GAAA;AAAA;;AAOF;;;KAAY,cAAA,IAAkB,QAAA,EAAU,QAAA;;AAaxC;;;;;;;;;;cAAa,oBAAA,SAA6B,cAAA;EAChC,oBAAA,EAAsB,cAAA;EAEtB,qBAAA,EAAuB,cAAA;EAEvB,0BAAA;IACF,MAAA,EAAQ,cAAA;EAAA;IAAA,CACP,CAAA;EAAA;EAEP,gBAAA,EAAkB,QAAA;EAElB,kBAAA,EAAoB,UAAA;EASpB,cAAA,CAAA;EApBsD;;;;;EA6BtD,4BAAA,CAA6B,SAAA,WAAoB,UAAA;EA1BlB;;;;;;EA+D/B,qBAAA,WAAgC,UAAA,CAAA,CAC9B,UAAA,EAAY,UAAA,IACV,CAAA,mBAAoB,CAAA,EAAG,SAAA,CAAU,CAAA;EAzDrC;;;;;;EAyFA,mBAAA,CAAoB,QAAA,EAAU,QAAA,IAAY,CAAA,WAAY,CAAA;EAlChC;;;;;;EAsDtB,cAAA,CAAe,SAAA,EAAW,SAAA;EApDF;;;;;;EAiFxB,eAAA,CACE,UAAA,EAAY,UAAA;EA9BY;;;;;EA+D1B,oBAAA,CACE,KAAA,EAAO,eAAA;EAAA;;;;;;;EAmBT,YAAA,CACE,aAAA,EAAe,cAAA,EACf,eAAA,EAAiB,cAAA,EACjB,SAAA,YACC,cAAA;AAAA"}
+{"version":3,"file":"functional.d.ts","names":[],"sources":["../../src/structured_query/functional.ts"],"mappings":";;;;;;;;;KAkBK;EACH;EACA;EACA;EACA;EACA;EACA;;;;;;KAOU,kBAAkB,UAAU;;;;;;;;;;;;cAa3B,6BAA6B;EAChC,sBAAsB;EAEtB,uBAAuB;EAEvB;IACF,QAAQ;;KACP;;EAEP,kBAAkB;EAElB,oBAAoB;EASpB;;;;;;EASA,6BAA6B,oBAAoB;;;;;;;EAqCjD,sBAAsB,UAAU,YAC9B,YAAY,cACV,oBAAoB,GAAG,UAAU;;;;;;;EAgCrC,oBAAoB,UAAU,YAAY,YAAY;;;;;;;EAoBtD,eAAe,WAAW;;;;;;;EA6B1B,gBACE,YAAY;;;;;;EAiCd,qBACE,OAAO;;;;;;;;EAmBT,aACE,eAAe,gBACf,iBAAiB,gBACjB,qBACC"}

package/dist/structured_query/functional.js.map

@@ -1 +1 @@
-{"version":3,"file":"functional.js","names":[],"sources":["../../src/structured_query/functional.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n} from \"./ir.js\";\nimport { BaseTranslator } from \"./base.js\";\nimport { castValue, isFilterEmpty } from \"./utils.js\";\n\n/**\n * A type alias for an object that maps comparison operators to string or\n * number values. This is used in the comparison functions to determine\n * the result of a comparison operation.\n */\ntype ValueType = {\n  eq: string | number | boolean;\n  ne: string | number | boolean;\n  lt: string | number;\n  lte: string | number;\n  gt: string | number;\n  gte: string | number;\n};\n\n/**\n * A type alias for a function that takes a `Document` as an argument and\n * returns a boolean. This function is used as a filter for documents.\n */\nexport type FunctionFilter = (document: Document) => boolean;\n\n/**\n * A class that extends `BaseTranslator` to translate structured queries\n * into functional filters.\n * @example\n * ```typescript\n * const functionalTranslator = new FunctionalTranslator();\n * const relevantDocuments = await functionalTranslator.getRelevantDocuments(\n *   \"Which movies are rated higher than 8.5?\",\n * );\n * ```\n */\nexport class FunctionalTranslator extends BaseTranslator {\n  declare VisitOperationOutput: FunctionFilter;\n\n  declare VisitComparisonOutput: FunctionFilter;\n\n  declare VisitStructuredQueryOutput:\n    | { filter: FunctionFilter }\n    | { [k: string]: never };\n\n  allowedOperators: Operator[] = [Operators.and, Operators.or];\n\n  allowedComparators: Comparator[] = [\n    Comparators.eq,\n    Comparators.ne,\n    Comparators.gt,\n    Comparators.gte,\n    Comparators.lt,\n    Comparators.lte,\n  ];\n\n  formatFunction(): string {\n    throw new Error(\"Not implemented\");\n  }\n\n  /**\n   * Returns the allowed comparators for a given data type.\n   * @param input The input value to get the allowed comparators for.\n   * @returns An array of allowed comparators for the input data type.\n   */\n  getAllowedComparatorsForType(inputType: string): Comparator[] {\n    switch (inputType) {\n      case \"string\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"number\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"boolean\": {\n        return [Comparators.eq, Comparators.ne];\n      }\n      default: {\n        throw new Error(`Unsupported data type: ${inputType}`);\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs a comparison based on the provided\n   * comparator.\n   * @param comparator The comparator to base the comparison function on.\n   * @returns A function that takes two arguments and returns a boolean based on the comparison.\n   */\n  getComparatorFunction<C extends Comparator>(\n    comparator: Comparator\n  ): (a: string | number, b: ValueType[C]) => boolean {\n    switch (comparator) {\n      case Comparators.eq: {\n        return (a: string | number, b: ValueType[C]) => a === b;\n      }\n      case Comparators.ne: {\n        return (a: string | number, b: ValueType[C]) => a !== b;\n      }\n      case Comparators.gt: {\n        return (a: string | number, b: ValueType[C]) => a > b;\n      }\n      case Comparators.gte: {\n        return (a: string | number, b: ValueType[C]) => a >= b;\n      }\n      case Comparators.lt: {\n        return (a: string | number, b: ValueType[C]) => a < b;\n      }\n      case Comparators.lte: {\n        return (a: string | number, b: ValueType[C]) => a <= b;\n      }\n      default: {\n        throw new Error(\"Unknown comparator\");\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs an operation based on the provided\n   * operator.\n   * @param operator The operator to base the operation function on.\n   * @returns A function that takes two boolean arguments and returns a boolean based on the operation.\n   */\n  getOperatorFunction(operator: Operator): (a: boolean, b: boolean) => boolean {\n    switch (operator) {\n      case Operators.and: {\n        return (a, b) => a && b;\n      }\n      case Operators.or: {\n        return (a, b) => a || b;\n      }\n      default: {\n        throw new Error(\"Unknown operator\");\n      }\n    }\n  }\n\n  /**\n   * Visits the operation part of a structured query and translates it into\n   * a functional filter.\n   * @param operation The operation part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const { operator, args } = operation;\n    if (this.allowedOperators.includes(operator)) {\n      const operatorFunction = this.getOperatorFunction(operator);\n      return (document: Document) => {\n        if (!args) {\n          return true;\n        }\n\n        return args.reduce((acc, arg) => {\n          const result = arg.accept(this);\n          if (typeof result === \"function\") {\n            return operatorFunction(acc, result(document));\n          } else {\n            throw new Error(\"Filter is not a function\");\n          }\n        }, true);\n      };\n    } else {\n      throw new Error(\"Operator not allowed\");\n    }\n  }\n\n  /**\n   * Visits the comparison part of a structured query and translates it into\n   * a functional filter.\n   * @param comparison The comparison part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.\n   */\n  visitComparison(\n    comparison: Comparison<string | number | boolean>\n  ): this[\"VisitComparisonOutput\"] {\n    const { comparator, attribute, value } = comparison;\n    const undefinedTrue = [Comparators.ne];\n    if (this.allowedComparators.includes(comparator)) {\n      if (\n        !this.getAllowedComparatorsForType(typeof value).includes(comparator)\n      ) {\n        throw new Error(\n          `'${comparator}' comparator not allowed to be used with ${typeof value}`\n        );\n      }\n      const comparatorFunction = this.getComparatorFunction(comparator);\n      return (document: Document) => {\n        const documentValue = document.metadata[attribute];\n        if (documentValue === undefined) {\n          if (undefinedTrue.includes(comparator)) {\n            return true;\n          }\n          return false;\n        }\n        return comparatorFunction(documentValue, castValue(value));\n      };\n    } else {\n      throw new Error(\"Comparator not allowed\");\n    }\n  }\n\n  /**\n   * Visits a structured query and translates it into a functional filter.\n   * @param query The structured query to translate.\n   * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    if (!query.filter) {\n      return {};\n    }\n    const filterFunction = query.filter?.accept(this);\n    if (typeof filterFunction !== \"function\") {\n      throw new Error(\"Structured query filter is not a function\");\n    }\n    return { filter: filterFunction as FunctionFilter };\n  }\n\n  /**\n   * Merges two filters into one, based on the specified merge type.\n   * @param defaultFilter The default filter function.\n   * @param generatedFilter The generated filter function.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.\n   */\n  mergeFilters(\n    defaultFilter: FunctionFilter,\n    generatedFilter: FunctionFilter,\n    mergeType = \"and\"\n  ): FunctionFilter | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n\n    if (mergeType === \"and\") {\n      return (document: Document) =>\n        defaultFilter(document) && generatedFilter(document);\n    } else if (mergeType === \"or\") {\n      return (document: Document) =>\n        defaultFilter(document) || generatedFilter(document);\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"functional.js","names":[],"sources":["../../src/structured_query/functional.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\nimport {\n  Comparator,\n  Comparators,\n  Comparison,\n  Operation,\n  Operator,\n  Operators,\n  StructuredQuery,\n} from \"./ir.js\";\nimport { BaseTranslator } from \"./base.js\";\nimport { castValue, isFilterEmpty } from \"./utils.js\";\n\n/**\n * A type alias for an object that maps comparison operators to string or\n * number values. This is used in the comparison functions to determine\n * the result of a comparison operation.\n */\ntype ValueType = {\n  eq: string | number | boolean;\n  ne: string | number | boolean;\n  lt: string | number;\n  lte: string | number;\n  gt: string | number;\n  gte: string | number;\n};\n\n/**\n * A type alias for a function that takes a `Document` as an argument and\n * returns a boolean. This function is used as a filter for documents.\n */\nexport type FunctionFilter = (document: Document) => boolean;\n\n/**\n * A class that extends `BaseTranslator` to translate structured queries\n * into functional filters.\n * @example\n * ```typescript\n * const functionalTranslator = new FunctionalTranslator();\n * const relevantDocuments = await functionalTranslator.getRelevantDocuments(\n *   \"Which movies are rated higher than 8.5?\",\n * );\n * ```\n */\nexport class FunctionalTranslator extends BaseTranslator {\n  declare VisitOperationOutput: FunctionFilter;\n\n  declare VisitComparisonOutput: FunctionFilter;\n\n  declare VisitStructuredQueryOutput:\n    | { filter: FunctionFilter }\n    | { [k: string]: never };\n\n  allowedOperators: Operator[] = [Operators.and, Operators.or];\n\n  allowedComparators: Comparator[] = [\n    Comparators.eq,\n    Comparators.ne,\n    Comparators.gt,\n    Comparators.gte,\n    Comparators.lt,\n    Comparators.lte,\n  ];\n\n  formatFunction(): string {\n    throw new Error(\"Not implemented\");\n  }\n\n  /**\n   * Returns the allowed comparators for a given data type.\n   * @param input The input value to get the allowed comparators for.\n   * @returns An array of allowed comparators for the input data type.\n   */\n  getAllowedComparatorsForType(inputType: string): Comparator[] {\n    switch (inputType) {\n      case \"string\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"number\": {\n        return [\n          Comparators.eq,\n          Comparators.ne,\n          Comparators.gt,\n          Comparators.gte,\n          Comparators.lt,\n          Comparators.lte,\n        ];\n      }\n      case \"boolean\": {\n        return [Comparators.eq, Comparators.ne];\n      }\n      default: {\n        throw new Error(`Unsupported data type: ${inputType}`);\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs a comparison based on the provided\n   * comparator.\n   * @param comparator The comparator to base the comparison function on.\n   * @returns A function that takes two arguments and returns a boolean based on the comparison.\n   */\n  getComparatorFunction<C extends Comparator>(\n    comparator: Comparator\n  ): (a: string | number, b: ValueType[C]) => boolean {\n    switch (comparator) {\n      case Comparators.eq: {\n        return (a: string | number, b: ValueType[C]) => a === b;\n      }\n      case Comparators.ne: {\n        return (a: string | number, b: ValueType[C]) => a !== b;\n      }\n      case Comparators.gt: {\n        return (a: string | number, b: ValueType[C]) => a > b;\n      }\n      case Comparators.gte: {\n        return (a: string | number, b: ValueType[C]) => a >= b;\n      }\n      case Comparators.lt: {\n        return (a: string | number, b: ValueType[C]) => a < b;\n      }\n      case Comparators.lte: {\n        return (a: string | number, b: ValueType[C]) => a <= b;\n      }\n      default: {\n        throw new Error(\"Unknown comparator\");\n      }\n    }\n  }\n\n  /**\n   * Returns a function that performs an operation based on the provided\n   * operator.\n   * @param operator The operator to base the operation function on.\n   * @returns A function that takes two boolean arguments and returns a boolean based on the operation.\n   */\n  getOperatorFunction(operator: Operator): (a: boolean, b: boolean) => boolean {\n    switch (operator) {\n      case Operators.and: {\n        return (a, b) => a && b;\n      }\n      case Operators.or: {\n        return (a, b) => a || b;\n      }\n      default: {\n        throw new Error(\"Unknown operator\");\n      }\n    }\n  }\n\n  /**\n   * Visits the operation part of a structured query and translates it into\n   * a functional filter.\n   * @param operation The operation part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.\n   */\n  visitOperation(operation: Operation): this[\"VisitOperationOutput\"] {\n    const { operator, args } = operation;\n    if (this.allowedOperators.includes(operator)) {\n      const operatorFunction = this.getOperatorFunction(operator);\n      return (document: Document) => {\n        if (!args) {\n          return true;\n        }\n\n        return args.reduce((acc, arg) => {\n          const result = arg.accept(this);\n          if (typeof result === \"function\") {\n            return operatorFunction(acc, result(document));\n          } else {\n            throw new Error(\"Filter is not a function\");\n          }\n        }, true);\n      };\n    } else {\n      throw new Error(\"Operator not allowed\");\n    }\n  }\n\n  /**\n   * Visits the comparison part of a structured query and translates it into\n   * a functional filter.\n   * @param comparison The comparison part of a structured query.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.\n   */\n  visitComparison(\n    comparison: Comparison<string | number | boolean>\n  ): this[\"VisitComparisonOutput\"] {\n    const { comparator, attribute, value } = comparison;\n    const undefinedTrue = [Comparators.ne];\n    if (this.allowedComparators.includes(comparator)) {\n      if (\n        !this.getAllowedComparatorsForType(typeof value).includes(comparator)\n      ) {\n        throw new Error(\n          `'${comparator}' comparator not allowed to be used with ${typeof value}`\n        );\n      }\n      const comparatorFunction = this.getComparatorFunction(comparator);\n      return (document: Document) => {\n        const documentValue = document.metadata[attribute];\n        if (documentValue === undefined) {\n          if (undefinedTrue.includes(comparator)) {\n            return true;\n          }\n          return false;\n        }\n        return comparatorFunction(documentValue, castValue(value));\n      };\n    } else {\n      throw new Error(\"Comparator not allowed\");\n    }\n  }\n\n  /**\n   * Visits a structured query and translates it into a functional filter.\n   * @param query The structured query to translate.\n   * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.\n   */\n  visitStructuredQuery(\n    query: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"] {\n    if (!query.filter) {\n      return {};\n    }\n    const filterFunction = query.filter?.accept(this);\n    if (typeof filterFunction !== \"function\") {\n      throw new Error(\"Structured query filter is not a function\");\n    }\n    return { filter: filterFunction as FunctionFilter };\n  }\n\n  /**\n   * Merges two filters into one, based on the specified merge type.\n   * @param defaultFilter The default filter function.\n   * @param generatedFilter The generated filter function.\n   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.\n   * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.\n   */\n  mergeFilters(\n    defaultFilter: FunctionFilter,\n    generatedFilter: FunctionFilter,\n    mergeType = \"and\"\n  ): FunctionFilter | undefined {\n    if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {\n      return undefined;\n    }\n    if (isFilterEmpty(defaultFilter) || mergeType === \"replace\") {\n      if (isFilterEmpty(generatedFilter)) {\n        return undefined;\n      }\n      return generatedFilter;\n    }\n    if (isFilterEmpty(generatedFilter)) {\n      if (mergeType === \"and\") {\n        return undefined;\n      }\n      return defaultFilter;\n    }\n\n    if (mergeType === \"and\") {\n      return (document: Document) =>\n        defaultFilter(document) && generatedFilter(document);\n    } else if (mergeType === \"or\") {\n      return (document: Document) =>\n        defaultFilter(document) || generatedFilter(document);\n    } else {\n      throw new Error(\"Unknown merge type\");\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/structured_query/ir.cjs

@@ -39,6 +39,9 @@ var FilterDirective = class extends Expression {};
 * FilterDirective class.
 */
 var Comparison = class extends FilterDirective {
+	comparator;
+	attribute;
+	value;
 	exprName = "Comparison";
 	constructor(comparator, attribute, value) {
 		super();
@@ -52,6 +55,8 @@ var Comparison = class extends FilterDirective {
 * FilterDirective class.
 */
 var Operation = class extends FilterDirective {
+	operator;
+	args;
 	exprName = "Operation";
 	constructor(operator, args) {
 		super();
@@ -64,6 +69,8 @@ var Operation = class extends FilterDirective {
 * Expression class.
 */
 var StructuredQuery = class extends Expression {
+	query;
+	filter;
 	exprName = "StructuredQuery";
 	constructor(query, filter) {
 		super();

package/dist/structured_query/ir.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ir.cjs","names":[],"sources":["../../src/structured_query/ir.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\n\nexport const Operators: { [key: string]: Operator } = {\n  and: \"and\",\n  or: \"or\",\n  not: \"not\",\n};\n\nexport const Comparators: { [key: string]: Comparator } = {\n  eq: \"eq\",\n  ne: \"ne\",\n  lt: \"lt\",\n  gt: \"gt\",\n  lte: \"lte\",\n  gte: \"gte\",\n};\n\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n  [operator: string]: VisitorResult[];\n};\n\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n  [attr: string]: {\n    [comparator: string]: string | number | boolean;\n  };\n};\n\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n  filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport abstract class Visitor<T extends VectorStore = VectorStore> {\n  declare VisitOperationOutput: object;\n\n  declare VisitComparisonOutput: object;\n\n  declare VisitStructuredQueryOutput: { filter?: T[\"FilterType\"] };\n\n  abstract allowedOperators: Operator[];\n\n  abstract allowedComparators: Comparator[];\n\n  abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n\n  abstract visitComparison(\n    comparison: Comparison\n  ): this[\"VisitComparisonOutput\"];\n\n  abstract visitStructuredQuery(\n    structuredQuery: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"];\n}\n\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport abstract class Expression {\n  abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n\n  accept(visitor: Visitor) {\n    if (this.exprName === \"Operation\") {\n      return visitor.visitOperation(this as unknown as Operation);\n    } else if (this.exprName === \"Comparison\") {\n      return visitor.visitComparison(this as unknown as Comparison);\n    } else if (this.exprName === \"StructuredQuery\") {\n      return visitor.visitStructuredQuery(this as unknown as StructuredQuery);\n    } else {\n      throw new Error(\"Unknown Expression type\");\n    }\n  }\n}\n\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport abstract class FilterDirective extends Expression {}\n\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport class Comparison<ValueTypes = string | number> extends FilterDirective {\n  exprName = \"Comparison\" as const;\n\n  constructor(\n    public comparator: Comparator,\n    public attribute: string,\n    public value: ValueTypes\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport class Operation extends FilterDirective {\n  exprName = \"Operation\" as const;\n\n  constructor(\n    public operator: Operator,\n    public args?: FilterDirective[]\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport class StructuredQuery extends Expression {\n  exprName = \"StructuredQuery\" as const;\n\n  constructor(\n    public query: string,\n    public filter?: FilterDirective\n  ) {\n    super();\n  }\n}\n"],"mappings":";AAmDA,MAAa,YAAyC;CACpD,KAAK;CACL,IAAI;CACJ,KAAK;CACN;AAED,MAAa,cAA6C;CACxD,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,KAAK;CACN;;;;;AAmCD,IAAsB,UAAtB,MAAmE;;;;;AA0BnE,IAAsB,aAAtB,MAAiC;CAG/B,OAAO,SAAkB;AACvB,MAAI,KAAK,aAAa,YACpB,QAAO,QAAQ,eAAe,KAA6B;WAClD,KAAK,aAAa,aAC3B,QAAO,QAAQ,gBAAgB,KAA8B;WACpD,KAAK,aAAa,kBAC3B,QAAO,QAAQ,qBAAqB,KAAmC;MAEvE,OAAM,IAAI,MAAM,0BAA0B;;;;;;;AAShD,IAAsB,kBAAtB,cAA8C,WAAW;;;;;AAMzD,IAAa,aAAb,cAA8D,gBAAgB;CAC5E,WAAW;CAEX,YACE,YACA,WACA,OACA;AACA,SAAO;AAJA,OAAA,aAAA;AACA,OAAA,YAAA;AACA,OAAA,QAAA;;;;;;;AAUX,IAAa,YAAb,cAA+B,gBAAgB;CAC7C,WAAW;CAEX,YACE,UACA,MACA;AACA,SAAO;AAHA,OAAA,WAAA;AACA,OAAA,OAAA;;;;;;;AAUX,IAAa,kBAAb,cAAqC,WAAW;CAC9C,WAAW;CAEX,YACE,OACA,QACA;AACA,SAAO;AAHA,OAAA,QAAA;AACA,OAAA,SAAA"}
+{"version":3,"file":"ir.cjs","names":[],"sources":["../../src/structured_query/ir.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\n\nexport const Operators: { [key: string]: Operator } = {\n  and: \"and\",\n  or: \"or\",\n  not: \"not\",\n};\n\nexport const Comparators: { [key: string]: Comparator } = {\n  eq: \"eq\",\n  ne: \"ne\",\n  lt: \"lt\",\n  gt: \"gt\",\n  lte: \"lte\",\n  gte: \"gte\",\n};\n\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n  [operator: string]: VisitorResult[];\n};\n\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n  [attr: string]: {\n    [comparator: string]: string | number | boolean;\n  };\n};\n\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n  filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport abstract class Visitor<T extends VectorStore = VectorStore> {\n  declare VisitOperationOutput: object;\n\n  declare VisitComparisonOutput: object;\n\n  declare VisitStructuredQueryOutput: { filter?: T[\"FilterType\"] };\n\n  abstract allowedOperators: Operator[];\n\n  abstract allowedComparators: Comparator[];\n\n  abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n\n  abstract visitComparison(\n    comparison: Comparison\n  ): this[\"VisitComparisonOutput\"];\n\n  abstract visitStructuredQuery(\n    structuredQuery: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"];\n}\n\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport abstract class Expression {\n  abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n\n  accept(visitor: Visitor) {\n    if (this.exprName === \"Operation\") {\n      return visitor.visitOperation(this as unknown as Operation);\n    } else if (this.exprName === \"Comparison\") {\n      return visitor.visitComparison(this as unknown as Comparison);\n    } else if (this.exprName === \"StructuredQuery\") {\n      return visitor.visitStructuredQuery(this as unknown as StructuredQuery);\n    } else {\n      throw new Error(\"Unknown Expression type\");\n    }\n  }\n}\n\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport abstract class FilterDirective extends Expression {}\n\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport class Comparison<ValueTypes = string | number> extends FilterDirective {\n  exprName = \"Comparison\" as const;\n\n  constructor(\n    public comparator: Comparator,\n    public attribute: string,\n    public value: ValueTypes\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport class Operation extends FilterDirective {\n  exprName = \"Operation\" as const;\n\n  constructor(\n    public operator: Operator,\n    public args?: FilterDirective[]\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport class StructuredQuery extends Expression {\n  exprName = \"StructuredQuery\" as const;\n\n  constructor(\n    public query: string,\n    public filter?: FilterDirective\n  ) {\n    super();\n  }\n}\n"],"mappings":";AAmDA,MAAa,YAAyC;CACpD,KAAK;CACL,IAAI;CACJ,KAAK;AACP;AAEA,MAAa,cAA6C;CACxD,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,KAAK;AACP;;;;;AAmCA,IAAsB,UAAtB,MAAmE,CAoBnE;;;;;AAMA,IAAsB,aAAtB,MAAiC;CAG/B,OAAO,SAAkB;EACvB,IAAI,KAAK,aAAa,aACpB,OAAO,QAAQ,eAAe,IAA4B;OACrD,IAAI,KAAK,aAAa,cAC3B,OAAO,QAAQ,gBAAgB,IAA6B;OACvD,IAAI,KAAK,aAAa,mBAC3B,OAAO,QAAQ,qBAAqB,IAAkC;OAEtE,MAAM,IAAI,MAAM,yBAAyB;CAE7C;AACF;;;;;AAMA,IAAsB,kBAAtB,cAA8C,WAAW,CAAC;;;;;AAM1D,IAAa,aAAb,cAA8D,gBAAgB;CAInE;CACA;CACA;CALT,WAAW;CAEX,YACE,YACA,WACA,OACA;EACA,MAAM;EAJC,KAAA,aAAA;EACA,KAAA,YAAA;EACA,KAAA,QAAA;CAGT;AACF;;;;;AAMA,IAAa,YAAb,cAA+B,gBAAgB;CAIpC;CACA;CAJT,WAAW;CAEX,YACE,UACA,MACA;EACA,MAAM;EAHC,KAAA,WAAA;EACA,KAAA,OAAA;CAGT;AACF;;;;;AAMA,IAAa,kBAAb,cAAqC,WAAW;CAIrC;CACA;CAJT,WAAW;CAEX,YACE,OACA,QACA;EACA,MAAM;EAHC,KAAA,QAAA;EACA,KAAA,SAAA;CAGT;AACF"}

package/dist/structured_query/ir.d.cts

@@ -1,5 +1,4 @@
 import { VectorStore } from "../vectorstores.cjs";
-
 //#region src/structured_query/ir.d.ts
 /**
  * Represents logical AND operator.

package/dist/structured_query/ir.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"ir.d.cts","names":[],"sources":["../../src/structured_query/ir.ts"],"mappings":";;;;;AAKA;KAAY,GAAA;;;;KAIA,EAAA;;;;KAIA,GAAA;AAAZ;;;AAAA,KAKY,QAAA,GAAW,GAAA,GAAM,EAAA,GAAK,GAAA;;AAAlC;;KAKY,EAAA;;;;KAIA,EAAA;;;;KAIA,EAAA;;;AARZ;KAYY,EAAA;;;;KAIA,GAAA;;;;KAIA,GAAA;AAZZ;;;;AAAA,KAkBY,UAAA,GAAa,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,GAAA,GAAM,GAAA;AAAA,cAEtC,SAAA;EAAA,CAAc,GAAA,WAAc,QAAA;AAAA;AAAA,cAM5B,WAAA;EAAA,CAAgB,GAAA,WAAc,UAAA;AAAA;;;;;KAa/B,aAAA,GAAgB,sBAAA,GAAyB,uBAAA;;;;KAKzC,sBAAA;EAAA,CACT,QAAA,WAAmB,aAAA;AAAA;;;;KAMV,uBAAA;EAAA,CACT,IAAA;IAAA,CACE,UAAA;EAAA;AAAA;;;;KAOO,4BAAA;EACV,MAAA,GAAS,uBAAA,GAA0B,sBAAA;AAAA;;;;AAzCrC;uBAgDsB,OAAA,WAAkB,WAAA,GAAc,WAAA;EAC5C,oBAAA;EAEA,qBAAA;EAEA,0BAAA;IAA8B,MAAA,GAAS,CAAA;EAAA;EAAA,SAEtC,gBAAA,EAAkB,QAAA;EAAA,SAElB,kBAAA,EAAoB,UAAA;EAAA,SAEpB,cAAA,CAAe,SAAA,EAAW,SAAA;EAAA,SAE1B,eAAA,CACP,UAAA,EAAY,UAAA;EAAA,SAGL,oBAAA,CACP,eAAA,EAAiB,eAAA;AAAA;;;AA1CrB;;uBAkDsB,UAAA;EAAA,SACX,QAAA;EAET,MAAA,CAAO,OAAA,EAAS,OAAA;AAAA;;;;;uBAiBI,eAAA,SAAwB,UAAA;;;;;cAMjC,UAAA,uCAAiD,eAAA;EAInD,UAAA,EAAY,UAAA;EACZ,SAAA;EACA,KAAA,EAAO,UAAA;EALhB,QAAA;EAEA,WAAA,CACS,UAAA,EAAY,UAAA,EACZ,SAAA,UACA,KAAA,EAAO,UAAA;AAAA;;;;;cAUL,SAAA,SAAkB,eAAA;EAIpB,QAAA,EAAU,QAAA;EACV,IAAA,GAAO,eAAA;EAJhB,QAAA;EAEA,WAAA,CACS,QAAA,EAAU,QAAA,EACV,IAAA,GAAO,eAAA;AAAA;;;;;cAUL,eAAA,SAAwB,UAAA;EAI1B,KAAA;EACA,MAAA,GAAS,eAAA;EAJlB,QAAA;EAEA,WAAA,CACS,KAAA,UACA,MAAA,GAAS,eAAA;AAAA"}
+{"version":3,"file":"ir.d.cts","names":[],"sources":["../../src/structured_query/ir.ts"],"mappings":";;;;;KAKY;;;;KAIA;;;;KAIA;;;;KAKA,WAAW,MAAM,KAAK;;;;KAKtB;;;;KAIA;;;;KAIA;;;;KAIA;;;;KAIA;;;;KAIA;;;;;KAMA,aAAa,KAAK,KAAK,KAAK,KAAK,MAAM;cAEtC;GAAc,cAAc;;cAM5B;GAAgB,cAAc;;;;;;KAa/B,gBAAgB,yBAAyB;;;;KAKzC;GACT,mBAAmB;;;;;KAMV;GACT;KACE;;;;;;KAOO;EACV,SAAS,0BAA0B;;;;;;uBAOf,QAAQ,UAAU,cAAc;EAC5C;EAEA;EAEA;IAA8B,SAAS;;WAEtC,kBAAkB;WAElB,oBAAoB;WAEpB,eAAe,WAAW;WAE1B,gBACP,YAAY;WAGL,qBACP,iBAAiB;;;;;;uBAQC;WACX;EAET,OAAO,SAAS;;;;;;uBAiBI,wBAAwB;;;;;cAMjC,WAAW,sCAAsC;EAInD,YAAY;EACZ;EACA,OAAO;EALhB;EAEA,YACS,YAAY,YACZ,mBACA,OAAO;;;;;;cAUL,kBAAkB;EAIpB,UAAU;EACV,OAAO;EAJhB;EAEA,YACS,UAAU,UACV,OAAO;;;;;;cAUL,wBAAwB;EAI1B;EACA,SAAS;EAJlB;EAEA,YACS,eACA,SAAS"}

package/dist/structured_query/ir.d.ts

@@ -1,5 +1,4 @@
 import { VectorStore } from "../vectorstores.js";
-
 //#region src/structured_query/ir.d.ts
 /**
  * Represents logical AND operator.

package/dist/structured_query/ir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ir.d.ts","names":[],"sources":["../../src/structured_query/ir.ts"],"mappings":";;;;;AAKA;KAAY,GAAA;;;;KAIA,EAAA;;;;KAIA,GAAA;AAAZ;;;AAAA,KAKY,QAAA,GAAW,GAAA,GAAM,EAAA,GAAK,GAAA;;AAAlC;;KAKY,EAAA;;;;KAIA,EAAA;;;;KAIA,EAAA;;;AARZ;KAYY,EAAA;;;;KAIA,GAAA;;;;KAIA,GAAA;AAZZ;;;;AAAA,KAkBY,UAAA,GAAa,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,GAAA,GAAM,GAAA;AAAA,cAEtC,SAAA;EAAA,CAAc,GAAA,WAAc,QAAA;AAAA;AAAA,cAM5B,WAAA;EAAA,CAAgB,GAAA,WAAc,UAAA;AAAA;;;;;KAa/B,aAAA,GAAgB,sBAAA,GAAyB,uBAAA;;;;KAKzC,sBAAA;EAAA,CACT,QAAA,WAAmB,aAAA;AAAA;;;;KAMV,uBAAA;EAAA,CACT,IAAA;IAAA,CACE,UAAA;EAAA;AAAA;;;;KAOO,4BAAA;EACV,MAAA,GAAS,uBAAA,GAA0B,sBAAA;AAAA;;;;AAzCrC;uBAgDsB,OAAA,WAAkB,WAAA,GAAc,WAAA;EAC5C,oBAAA;EAEA,qBAAA;EAEA,0BAAA;IAA8B,MAAA,GAAS,CAAA;EAAA;EAAA,SAEtC,gBAAA,EAAkB,QAAA;EAAA,SAElB,kBAAA,EAAoB,UAAA;EAAA,SAEpB,cAAA,CAAe,SAAA,EAAW,SAAA;EAAA,SAE1B,eAAA,CACP,UAAA,EAAY,UAAA;EAAA,SAGL,oBAAA,CACP,eAAA,EAAiB,eAAA;AAAA;;;AA1CrB;;uBAkDsB,UAAA;EAAA,SACX,QAAA;EAET,MAAA,CAAO,OAAA,EAAS,OAAA;AAAA;;;;;uBAiBI,eAAA,SAAwB,UAAA;;;;;cAMjC,UAAA,uCAAiD,eAAA;EAInD,UAAA,EAAY,UAAA;EACZ,SAAA;EACA,KAAA,EAAO,UAAA;EALhB,QAAA;EAEA,WAAA,CACS,UAAA,EAAY,UAAA,EACZ,SAAA,UACA,KAAA,EAAO,UAAA;AAAA;;;;;cAUL,SAAA,SAAkB,eAAA;EAIpB,QAAA,EAAU,QAAA;EACV,IAAA,GAAO,eAAA;EAJhB,QAAA;EAEA,WAAA,CACS,QAAA,EAAU,QAAA,EACV,IAAA,GAAO,eAAA;AAAA;;;;;cAUL,eAAA,SAAwB,UAAA;EAI1B,KAAA;EACA,MAAA,GAAS,eAAA;EAJlB,QAAA;EAEA,WAAA,CACS,KAAA,UACA,MAAA,GAAS,eAAA;AAAA"}
+{"version":3,"file":"ir.d.ts","names":[],"sources":["../../src/structured_query/ir.ts"],"mappings":";;;;;KAKY;;;;KAIA;;;;KAIA;;;;KAKA,WAAW,MAAM,KAAK;;;;KAKtB;;;;KAIA;;;;KAIA;;;;KAIA;;;;KAIA;;;;KAIA;;;;;KAMA,aAAa,KAAK,KAAK,KAAK,KAAK,MAAM;cAEtC;GAAc,cAAc;;cAM5B;GAAgB,cAAc;;;;;;KAa/B,gBAAgB,yBAAyB;;;;KAKzC;GACT,mBAAmB;;;;;KAMV;GACT;KACE;;;;;;KAOO;EACV,SAAS,0BAA0B;;;;;;uBAOf,QAAQ,UAAU,cAAc;EAC5C;EAEA;EAEA;IAA8B,SAAS;;WAEtC,kBAAkB;WAElB,oBAAoB;WAEpB,eAAe,WAAW;WAE1B,gBACP,YAAY;WAGL,qBACP,iBAAiB;;;;;;uBAQC;WACX;EAET,OAAO,SAAS;;;;;;uBAiBI,wBAAwB;;;;;cAMjC,WAAW,sCAAsC;EAInD,YAAY;EACZ;EACA,OAAO;EALhB;EAEA,YACS,YAAY,YACZ,mBACA,OAAO;;;;;;cAUL,kBAAkB;EAIpB,UAAU;EACV,OAAO;EAJhB;EAEA,YACS,UAAU,UACV,OAAO;;;;;;cAUL,wBAAwB;EAI1B;EACA,SAAS;EAJlB;EAEA,YACS,eACA,SAAS"}

package/dist/structured_query/ir.js

@@ -39,6 +39,9 @@ var FilterDirective = class extends Expression {};
 * FilterDirective class.
 */
 var Comparison = class extends FilterDirective {
+	comparator;
+	attribute;
+	value;
 	exprName = "Comparison";
 	constructor(comparator, attribute, value) {
 		super();
@@ -52,6 +55,8 @@ var Comparison = class extends FilterDirective {
 * FilterDirective class.
 */
 var Operation = class extends FilterDirective {
+	operator;
+	args;
 	exprName = "Operation";
 	constructor(operator, args) {
 		super();
@@ -64,6 +69,8 @@ var Operation = class extends FilterDirective {
 * Expression class.
 */
 var StructuredQuery = class extends Expression {
+	query;
+	filter;
 	exprName = "StructuredQuery";
 	constructor(query, filter) {
 		super();

package/dist/structured_query/ir.js.map

@@ -1 +1 @@
-{"version":3,"file":"ir.js","names":[],"sources":["../../src/structured_query/ir.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\n\nexport const Operators: { [key: string]: Operator } = {\n  and: \"and\",\n  or: \"or\",\n  not: \"not\",\n};\n\nexport const Comparators: { [key: string]: Comparator } = {\n  eq: \"eq\",\n  ne: \"ne\",\n  lt: \"lt\",\n  gt: \"gt\",\n  lte: \"lte\",\n  gte: \"gte\",\n};\n\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n  [operator: string]: VisitorResult[];\n};\n\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n  [attr: string]: {\n    [comparator: string]: string | number | boolean;\n  };\n};\n\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n  filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport abstract class Visitor<T extends VectorStore = VectorStore> {\n  declare VisitOperationOutput: object;\n\n  declare VisitComparisonOutput: object;\n\n  declare VisitStructuredQueryOutput: { filter?: T[\"FilterType\"] };\n\n  abstract allowedOperators: Operator[];\n\n  abstract allowedComparators: Comparator[];\n\n  abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n\n  abstract visitComparison(\n    comparison: Comparison\n  ): this[\"VisitComparisonOutput\"];\n\n  abstract visitStructuredQuery(\n    structuredQuery: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"];\n}\n\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport abstract class Expression {\n  abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n\n  accept(visitor: Visitor) {\n    if (this.exprName === \"Operation\") {\n      return visitor.visitOperation(this as unknown as Operation);\n    } else if (this.exprName === \"Comparison\") {\n      return visitor.visitComparison(this as unknown as Comparison);\n    } else if (this.exprName === \"StructuredQuery\") {\n      return visitor.visitStructuredQuery(this as unknown as StructuredQuery);\n    } else {\n      throw new Error(\"Unknown Expression type\");\n    }\n  }\n}\n\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport abstract class FilterDirective extends Expression {}\n\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport class Comparison<ValueTypes = string | number> extends FilterDirective {\n  exprName = \"Comparison\" as const;\n\n  constructor(\n    public comparator: Comparator,\n    public attribute: string,\n    public value: ValueTypes\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport class Operation extends FilterDirective {\n  exprName = \"Operation\" as const;\n\n  constructor(\n    public operator: Operator,\n    public args?: FilterDirective[]\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport class StructuredQuery extends Expression {\n  exprName = \"StructuredQuery\" as const;\n\n  constructor(\n    public query: string,\n    public filter?: FilterDirective\n  ) {\n    super();\n  }\n}\n"],"mappings":";AAmDA,MAAa,YAAyC;CACpD,KAAK;CACL,IAAI;CACJ,KAAK;CACN;AAED,MAAa,cAA6C;CACxD,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,KAAK;CACN;;;;;AAmCD,IAAsB,UAAtB,MAAmE;;;;;AA0BnE,IAAsB,aAAtB,MAAiC;CAG/B,OAAO,SAAkB;AACvB,MAAI,KAAK,aAAa,YACpB,QAAO,QAAQ,eAAe,KAA6B;WAClD,KAAK,aAAa,aAC3B,QAAO,QAAQ,gBAAgB,KAA8B;WACpD,KAAK,aAAa,kBAC3B,QAAO,QAAQ,qBAAqB,KAAmC;MAEvE,OAAM,IAAI,MAAM,0BAA0B;;;;;;;AAShD,IAAsB,kBAAtB,cAA8C,WAAW;;;;;AAMzD,IAAa,aAAb,cAA8D,gBAAgB;CAC5E,WAAW;CAEX,YACE,YACA,WACA,OACA;AACA,SAAO;AAJA,OAAA,aAAA;AACA,OAAA,YAAA;AACA,OAAA,QAAA;;;;;;;AAUX,IAAa,YAAb,cAA+B,gBAAgB;CAC7C,WAAW;CAEX,YACE,UACA,MACA;AACA,SAAO;AAHA,OAAA,WAAA;AACA,OAAA,OAAA;;;;;;;AAUX,IAAa,kBAAb,cAAqC,WAAW;CAC9C,WAAW;CAEX,YACE,OACA,QACA;AACA,SAAO;AAHA,OAAA,QAAA;AACA,OAAA,SAAA"}
+{"version":3,"file":"ir.js","names":[],"sources":["../../src/structured_query/ir.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\n\nexport const Operators: { [key: string]: Operator } = {\n  and: \"and\",\n  or: \"or\",\n  not: \"not\",\n};\n\nexport const Comparators: { [key: string]: Comparator } = {\n  eq: \"eq\",\n  ne: \"ne\",\n  lt: \"lt\",\n  gt: \"gt\",\n  lte: \"lte\",\n  gte: \"gte\",\n};\n\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n  [operator: string]: VisitorResult[];\n};\n\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n  [attr: string]: {\n    [comparator: string]: string | number | boolean;\n  };\n};\n\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n  filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport abstract class Visitor<T extends VectorStore = VectorStore> {\n  declare VisitOperationOutput: object;\n\n  declare VisitComparisonOutput: object;\n\n  declare VisitStructuredQueryOutput: { filter?: T[\"FilterType\"] };\n\n  abstract allowedOperators: Operator[];\n\n  abstract allowedComparators: Comparator[];\n\n  abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n\n  abstract visitComparison(\n    comparison: Comparison\n  ): this[\"VisitComparisonOutput\"];\n\n  abstract visitStructuredQuery(\n    structuredQuery: StructuredQuery\n  ): this[\"VisitStructuredQueryOutput\"];\n}\n\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport abstract class Expression {\n  abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n\n  accept(visitor: Visitor) {\n    if (this.exprName === \"Operation\") {\n      return visitor.visitOperation(this as unknown as Operation);\n    } else if (this.exprName === \"Comparison\") {\n      return visitor.visitComparison(this as unknown as Comparison);\n    } else if (this.exprName === \"StructuredQuery\") {\n      return visitor.visitStructuredQuery(this as unknown as StructuredQuery);\n    } else {\n      throw new Error(\"Unknown Expression type\");\n    }\n  }\n}\n\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport abstract class FilterDirective extends Expression {}\n\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport class Comparison<ValueTypes = string | number> extends FilterDirective {\n  exprName = \"Comparison\" as const;\n\n  constructor(\n    public comparator: Comparator,\n    public attribute: string,\n    public value: ValueTypes\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport class Operation extends FilterDirective {\n  exprName = \"Operation\" as const;\n\n  constructor(\n    public operator: Operator,\n    public args?: FilterDirective[]\n  ) {\n    super();\n  }\n}\n\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport class StructuredQuery extends Expression {\n  exprName = \"StructuredQuery\" as const;\n\n  constructor(\n    public query: string,\n    public filter?: FilterDirective\n  ) {\n    super();\n  }\n}\n"],"mappings":";AAmDA,MAAa,YAAyC;CACpD,KAAK;CACL,IAAI;CACJ,KAAK;AACP;AAEA,MAAa,cAA6C;CACxD,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,KAAK;AACP;;;;;AAmCA,IAAsB,UAAtB,MAAmE,CAoBnE;;;;;AAMA,IAAsB,aAAtB,MAAiC;CAG/B,OAAO,SAAkB;EACvB,IAAI,KAAK,aAAa,aACpB,OAAO,QAAQ,eAAe,IAA4B;OACrD,IAAI,KAAK,aAAa,cAC3B,OAAO,QAAQ,gBAAgB,IAA6B;OACvD,IAAI,KAAK,aAAa,mBAC3B,OAAO,QAAQ,qBAAqB,IAAkC;OAEtE,MAAM,IAAI,MAAM,yBAAyB;CAE7C;AACF;;;;;AAMA,IAAsB,kBAAtB,cAA8C,WAAW,CAAC;;;;;AAM1D,IAAa,aAAb,cAA8D,gBAAgB;CAInE;CACA;CACA;CALT,WAAW;CAEX,YACE,YACA,WACA,OACA;EACA,MAAM;EAJC,KAAA,aAAA;EACA,KAAA,YAAA;EACA,KAAA,QAAA;CAGT;AACF;;;;;AAMA,IAAa,YAAb,cAA+B,gBAAgB;CAIpC;CACA;CAJT,WAAW;CAEX,YACE,UACA,MACA;EACA,MAAM;EAHC,KAAA,WAAA;EACA,KAAA,OAAA;CAGT;AACF;;;;;AAMA,IAAa,kBAAb,cAAqC,WAAW;CAIrC;CACA;CAJT,WAAW;CAEX,YACE,OACA,QACA;EACA,MAAM;EAHC,KAAA,QAAA;EACA,KAAA,SAAA;CAGT;AACF"}

package/dist/structured_query/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":[],"sources":["../../src/structured_query/utils.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isObject(obj: any): obj is object {\n  return obj && typeof obj === \"object\" && !Array.isArray(obj);\n}\n\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport function isFilterEmpty(\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  filter: ((q: any) => any) | object | string | undefined\n): filter is undefined {\n  if (!filter) return true;\n  // for Milvus\n  if (typeof filter === \"string\" && filter.length > 0) {\n    return false;\n  }\n  if (typeof filter === \"function\") {\n    return false;\n  }\n  return isObject(filter) && Object.keys(filter).length === 0;\n}\n\n/**\n * Checks if the provided value is an integer.\n */\nexport function isInt(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 === 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseInt(value, 10);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 === 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport function isFloat(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 !== 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseFloat(value);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 !== 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport function isString(value: unknown): boolean {\n  return (\n    typeof value === \"string\" &&\n    (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value)\n  );\n}\n\n/**\n * Checks if the provided value is a boolean.\n */\nexport function isBoolean(value: unknown): boolean {\n  return typeof value === \"boolean\";\n}\n\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport function castValue(input: unknown): string | number | boolean {\n  let value;\n  if (isString(input)) {\n    value = input as string;\n  } else if (isInt(input)) {\n    value = parseInt(input as string, 10);\n  } else if (isFloat(input)) {\n    value = parseFloat(input as string);\n  } else if (isBoolean(input)) {\n    value = Boolean(input);\n  } else {\n    throw new Error(\"Unsupported value type\");\n  }\n\n  return value;\n}\n"],"mappings":";;;;AAIA,SAAgB,SAAS,KAAyB;AAChD,QAAO,OAAO,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,IAAI;;;;;;AAO9D,SAAgB,cAEd,QACqB;AACrB,KAAI,CAAC,OAAQ,QAAO;AAEpB,KAAI,OAAO,WAAW,YAAY,OAAO,SAAS,EAChD,QAAO;AAET,KAAI,OAAO,WAAW,WACpB,QAAO;AAET,QAAO,SAAS,OAAO,IAAI,OAAO,KAAK,OAAO,CAAC,WAAW;;;;;AAM5D,SAAgB,MAAM,OAAyB;AAC7C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,SAAS,OAAO,GAAG;AACvC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;;AAI/B,QAAO;;;;;AAMT,SAAgB,QAAQ,OAAyB;AAC/C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,WAAW,MAAM;AACrC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;;AAI/B,QAAO;;;;;;AAOT,SAAgB,SAAS,OAAyB;AAChD,QACE,OAAO,UAAU,aAChB,OAAO,MAAM,WAAW,MAAM,CAAC,IAAI,WAAW,MAAM,CAAC,UAAU,KAAK;;;;;AAOzE,SAAgB,UAAU,OAAyB;AACjD,QAAO,OAAO,UAAU;;;;;;;;AAS1B,SAAgB,UAAU,OAA2C;CACnE,IAAI;AACJ,KAAI,SAAS,MAAM,CACjB,SAAQ;UACC,MAAM,MAAM,CACrB,SAAQ,SAAS,OAAiB,GAAG;UAC5B,QAAQ,MAAM,CACvB,SAAQ,WAAW,MAAgB;UAC1B,UAAU,MAAM,CACzB,SAAQ,QAAQ,MAAM;KAEtB,OAAM,IAAI,MAAM,yBAAyB;AAG3C,QAAO"}
+{"version":3,"file":"utils.cjs","names":[],"sources":["../../src/structured_query/utils.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isObject(obj: any): obj is object {\n  return obj && typeof obj === \"object\" && !Array.isArray(obj);\n}\n\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport function isFilterEmpty(\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  filter: ((q: any) => any) | object | string | undefined\n): filter is undefined {\n  if (!filter) return true;\n  // for Milvus\n  if (typeof filter === \"string\" && filter.length > 0) {\n    return false;\n  }\n  if (typeof filter === \"function\") {\n    return false;\n  }\n  return isObject(filter) && Object.keys(filter).length === 0;\n}\n\n/**\n * Checks if the provided value is an integer.\n */\nexport function isInt(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 === 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseInt(value, 10);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 === 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport function isFloat(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 !== 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseFloat(value);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 !== 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport function isString(value: unknown): boolean {\n  return (\n    typeof value === \"string\" &&\n    (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value)\n  );\n}\n\n/**\n * Checks if the provided value is a boolean.\n */\nexport function isBoolean(value: unknown): boolean {\n  return typeof value === \"boolean\";\n}\n\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport function castValue(input: unknown): string | number | boolean {\n  let value;\n  if (isString(input)) {\n    value = input as string;\n  } else if (isInt(input)) {\n    value = parseInt(input as string, 10);\n  } else if (isFloat(input)) {\n    value = parseFloat(input as string);\n  } else if (isBoolean(input)) {\n    value = Boolean(input);\n  } else {\n    throw new Error(\"Unsupported value type\");\n  }\n\n  return value;\n}\n"],"mappings":";;;;AAIA,SAAgB,SAAS,KAAyB;CAChD,OAAO,OAAO,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,GAAG;AAC7D;;;;;AAMA,SAAgB,cAEd,QACqB;CACrB,IAAI,CAAC,QAAQ,OAAO;CAEpB,IAAI,OAAO,WAAW,YAAY,OAAO,SAAS,GAChD,OAAO;CAET,IAAI,OAAO,WAAW,YACpB,OAAO;CAET,OAAO,SAAS,MAAM,KAAK,OAAO,KAAK,MAAM,CAAC,CAAC,WAAW;AAC5D;;;;AAKA,SAAgB,MAAM,OAAyB;CAC7C,IAAI,OAAO,UAAU,UACnB,OAAO,QAAQ,MAAM;MAChB,IAAI,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,SAAS,OAAO,EAAE;EACtC,OACE,CAAC,OAAO,MAAM,WAAW,KACzB,cAAc,MAAM,KACpB,YAAY,SAAS,MAAM;CAE/B;CAEA,OAAO;AACT;;;;AAKA,SAAgB,QAAQ,OAAyB;CAC/C,IAAI,OAAO,UAAU,UACnB,OAAO,QAAQ,MAAM;MAChB,IAAI,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,WAAW,KAAK;EACpC,OACE,CAAC,OAAO,MAAM,WAAW,KACzB,cAAc,MAAM,KACpB,YAAY,SAAS,MAAM;CAE/B;CAEA,OAAO;AACT;;;;;AAMA,SAAgB,SAAS,OAAyB;CAChD,OACE,OAAO,UAAU,aAChB,OAAO,MAAM,WAAW,KAAK,CAAC,KAAK,WAAW,KAAK,CAAC,CAAC,SAAS,MAAM;AAEzE;;;;AAKA,SAAgB,UAAU,OAAyB;CACjD,OAAO,OAAO,UAAU;AAC1B;;;;;;;AAQA,SAAgB,UAAU,OAA2C;CACnE,IAAI;CACJ,IAAI,SAAS,KAAK,GAChB,QAAQ;MACH,IAAI,MAAM,KAAK,GACpB,QAAQ,SAAS,OAAiB,EAAE;MAC/B,IAAI,QAAQ,KAAK,GACtB,QAAQ,WAAW,KAAe;MAC7B,IAAI,UAAU,KAAK,GACxB,QAAQ,QAAQ,KAAK;MAErB,MAAM,IAAI,MAAM,wBAAwB;CAG1C,OAAO;AACT"}

package/dist/structured_query/utils.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.cts","names":[],"sources":["../../src/structured_query/utils.ts"],"mappings":";;AAIA;;iBAAgB,QAAA,CAAS,GAAA,QAAW,GAAA;;;AAQpC;;iBAAgB,aAAA,CAEd,MAAA,IAAU,CAAA,+CACT,MAAA;;;;iBAea,KAAA,CAAM,KAAA;;;AAAtB;iBAkBgB,OAAA,CAAQ,KAAA;;;;AAAxB;iBAmBgB,QAAA,CAAS,KAAA;;;;iBAUT,SAAA,CAAU,KAAA;;;;;AAA1B;;iBAUgB,SAAA,CAAU,KAAA"}
+{"version":3,"file":"utils.d.cts","names":[],"sources":["../../src/structured_query/utils.ts"],"mappings":";;;;iBAIgB,SAAS,WAAW;;;;;iBAQpB,cAEd,UAAU,gDACT;;;;iBAea,MAAM;;;;iBAkBN,QAAQ;;;;;iBAmBR,SAAS;;;;iBAUT,UAAU;;;;;;;iBAUV,UAAU"}

package/dist/structured_query/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/structured_query/utils.ts"],"mappings":";;AAIA;;iBAAgB,QAAA,CAAS,GAAA,QAAW,GAAA;;;AAQpC;;iBAAgB,aAAA,CAEd,MAAA,IAAU,CAAA,+CACT,MAAA;;;;iBAea,KAAA,CAAM,KAAA;;;AAAtB;iBAkBgB,OAAA,CAAQ,KAAA;;;;AAAxB;iBAmBgB,QAAA,CAAS,KAAA;;;;iBAUT,SAAA,CAAU,KAAA;;;;;AAA1B;;iBAUgB,SAAA,CAAU,KAAA"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/structured_query/utils.ts"],"mappings":";;;;iBAIgB,SAAS,WAAW;;;;;iBAQpB,cAEd,UAAU,gDACT;;;;iBAea,MAAM;;;;iBAkBN,QAAQ;;;;;iBAmBR,SAAS;;;;iBAUT,UAAU;;;;;;;iBAUV,UAAU"}

package/dist/structured_query/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../../src/structured_query/utils.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isObject(obj: any): obj is object {\n  return obj && typeof obj === \"object\" && !Array.isArray(obj);\n}\n\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport function isFilterEmpty(\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  filter: ((q: any) => any) | object | string | undefined\n): filter is undefined {\n  if (!filter) return true;\n  // for Milvus\n  if (typeof filter === \"string\" && filter.length > 0) {\n    return false;\n  }\n  if (typeof filter === \"function\") {\n    return false;\n  }\n  return isObject(filter) && Object.keys(filter).length === 0;\n}\n\n/**\n * Checks if the provided value is an integer.\n */\nexport function isInt(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 === 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseInt(value, 10);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 === 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport function isFloat(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 !== 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseFloat(value);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 !== 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport function isString(value: unknown): boolean {\n  return (\n    typeof value === \"string\" &&\n    (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value)\n  );\n}\n\n/**\n * Checks if the provided value is a boolean.\n */\nexport function isBoolean(value: unknown): boolean {\n  return typeof value === \"boolean\";\n}\n\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport function castValue(input: unknown): string | number | boolean {\n  let value;\n  if (isString(input)) {\n    value = input as string;\n  } else if (isInt(input)) {\n    value = parseInt(input as string, 10);\n  } else if (isFloat(input)) {\n    value = parseFloat(input as string);\n  } else if (isBoolean(input)) {\n    value = Boolean(input);\n  } else {\n    throw new Error(\"Unsupported value type\");\n  }\n\n  return value;\n}\n"],"mappings":";;;;AAIA,SAAgB,SAAS,KAAyB;AAChD,QAAO,OAAO,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,IAAI;;;;;;AAO9D,SAAgB,cAEd,QACqB;AACrB,KAAI,CAAC,OAAQ,QAAO;AAEpB,KAAI,OAAO,WAAW,YAAY,OAAO,SAAS,EAChD,QAAO;AAET,KAAI,OAAO,WAAW,WACpB,QAAO;AAET,QAAO,SAAS,OAAO,IAAI,OAAO,KAAK,OAAO,CAAC,WAAW;;;;;AAM5D,SAAgB,MAAM,OAAyB;AAC7C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,SAAS,OAAO,GAAG;AACvC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;;AAI/B,QAAO;;;;;AAMT,SAAgB,QAAQ,OAAyB;AAC/C,KAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,MAAM;UACZ,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,WAAW,MAAM;AACrC,SACE,CAAC,OAAO,MAAM,YAAY,IAC1B,cAAc,MAAM,KACpB,YAAY,UAAU,KAAK;;AAI/B,QAAO;;;;;;AAOT,SAAgB,SAAS,OAAyB;AAChD,QACE,OAAO,UAAU,aAChB,OAAO,MAAM,WAAW,MAAM,CAAC,IAAI,WAAW,MAAM,CAAC,UAAU,KAAK;;;;;AAOzE,SAAgB,UAAU,OAAyB;AACjD,QAAO,OAAO,UAAU;;;;;;;;AAS1B,SAAgB,UAAU,OAA2C;CACnE,IAAI;AACJ,KAAI,SAAS,MAAM,CACjB,SAAQ;UACC,MAAM,MAAM,CACrB,SAAQ,SAAS,OAAiB,GAAG;UAC5B,QAAQ,MAAM,CACvB,SAAQ,WAAW,MAAgB;UAC1B,UAAU,MAAM,CACzB,SAAQ,QAAQ,MAAM;KAEtB,OAAM,IAAI,MAAM,yBAAyB;AAG3C,QAAO"}
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/structured_query/utils.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isObject(obj: any): obj is object {\n  return obj && typeof obj === \"object\" && !Array.isArray(obj);\n}\n\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport function isFilterEmpty(\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  filter: ((q: any) => any) | object | string | undefined\n): filter is undefined {\n  if (!filter) return true;\n  // for Milvus\n  if (typeof filter === \"string\" && filter.length > 0) {\n    return false;\n  }\n  if (typeof filter === \"function\") {\n    return false;\n  }\n  return isObject(filter) && Object.keys(filter).length === 0;\n}\n\n/**\n * Checks if the provided value is an integer.\n */\nexport function isInt(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 === 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseInt(value, 10);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 === 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport function isFloat(value: unknown): boolean {\n  if (typeof value === \"number\") {\n    return value % 1 !== 0;\n  } else if (typeof value === \"string\") {\n    const numberValue = parseFloat(value);\n    return (\n      !Number.isNaN(numberValue) &&\n      numberValue % 1 !== 0 &&\n      numberValue.toString() === value\n    );\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport function isString(value: unknown): boolean {\n  return (\n    typeof value === \"string\" &&\n    (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value)\n  );\n}\n\n/**\n * Checks if the provided value is a boolean.\n */\nexport function isBoolean(value: unknown): boolean {\n  return typeof value === \"boolean\";\n}\n\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport function castValue(input: unknown): string | number | boolean {\n  let value;\n  if (isString(input)) {\n    value = input as string;\n  } else if (isInt(input)) {\n    value = parseInt(input as string, 10);\n  } else if (isFloat(input)) {\n    value = parseFloat(input as string);\n  } else if (isBoolean(input)) {\n    value = Boolean(input);\n  } else {\n    throw new Error(\"Unsupported value type\");\n  }\n\n  return value;\n}\n"],"mappings":";;;;AAIA,SAAgB,SAAS,KAAyB;CAChD,OAAO,OAAO,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,GAAG;AAC7D;;;;;AAMA,SAAgB,cAEd,QACqB;CACrB,IAAI,CAAC,QAAQ,OAAO;CAEpB,IAAI,OAAO,WAAW,YAAY,OAAO,SAAS,GAChD,OAAO;CAET,IAAI,OAAO,WAAW,YACpB,OAAO;CAET,OAAO,SAAS,MAAM,KAAK,OAAO,KAAK,MAAM,CAAC,CAAC,WAAW;AAC5D;;;;AAKA,SAAgB,MAAM,OAAyB;CAC7C,IAAI,OAAO,UAAU,UACnB,OAAO,QAAQ,MAAM;MAChB,IAAI,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,SAAS,OAAO,EAAE;EACtC,OACE,CAAC,OAAO,MAAM,WAAW,KACzB,cAAc,MAAM,KACpB,YAAY,SAAS,MAAM;CAE/B;CAEA,OAAO;AACT;;;;AAKA,SAAgB,QAAQ,OAAyB;CAC/C,IAAI,OAAO,UAAU,UACnB,OAAO,QAAQ,MAAM;MAChB,IAAI,OAAO,UAAU,UAAU;EACpC,MAAM,cAAc,WAAW,KAAK;EACpC,OACE,CAAC,OAAO,MAAM,WAAW,KACzB,cAAc,MAAM,KACpB,YAAY,SAAS,MAAM;CAE/B;CAEA,OAAO;AACT;;;;;AAMA,SAAgB,SAAS,OAAyB;CAChD,OACE,OAAO,UAAU,aAChB,OAAO,MAAM,WAAW,KAAK,CAAC,KAAK,WAAW,KAAK,CAAC,CAAC,SAAS,MAAM;AAEzE;;;;AAKA,SAAgB,UAAU,OAAyB;CACjD,OAAO,OAAO,UAAU;AAC1B;;;;;;;AAQA,SAAgB,UAAU,OAA2C;CACnE,IAAI;CACJ,IAAI,SAAS,KAAK,GAChB,QAAQ;MACH,IAAI,MAAM,KAAK,GACpB,QAAQ,SAAS,OAAiB,EAAE;MAC/B,IAAI,QAAQ,KAAK,GACtB,QAAQ,WAAW,KAAe;MAC7B,IAAI,UAAU,KAAK,GACxB,QAAQ,QAAQ,KAAK;MAErB,MAAM,IAAI,MAAM,wBAAwB;CAG1C,OAAO;AACT"}

package/dist/testing/fake_model_builder.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"fake_model_builder.cjs","names":["BaseChatModel","BaseMessage","RunnableLambda","AIMessage"],"sources":["../../src/testing/fake_model_builder.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport { CallbackManagerForLLMRun } from \"../callbacks/manager.js\";\nimport {\n  BaseChatModel,\n  BaseChatModelCallOptions,\n} from \"../language_models/chat_models.js\";\nimport {\n  BaseLanguageModelInput,\n  StructuredOutputMethodOptions,\n  StructuredOutputMethodParams,\n} from \"../language_models/base.js\";\nimport { BaseMessage, AIMessage } from \"../messages/index.js\";\nimport type { ToolCall } from \"../messages/tool.js\";\nimport type { ChatResult } from \"../outputs.js\";\nimport { Runnable, RunnableLambda } from \"../runnables/base.js\";\nimport { StructuredTool } from \"../tools/index.js\";\nimport type { InteropZodType } from \"../utils/types/zod.js\";\nimport type { ToolSpec } from \"../utils/testing/chat_models.js\";\n\ntype ResponseFactory = (messages: BaseMessage[]) => BaseMessage | Error;\n\ntype QueueEntry =\n  | { kind: \"message\"; message: BaseMessage }\n  | { kind: \"toolCalls\"; toolCalls: ToolCall[] }\n  | { kind: \"error\"; error: Error }\n  | { kind: \"factory\"; factory: ResponseFactory };\n\ninterface FakeModelCall {\n  messages: BaseMessage[];\n  options: any;\n}\n\ninterface FakeModelState {\n  callIndex: number;\n  calls: FakeModelCall[];\n}\n\nfunction deriveContent(messages: BaseMessage[]): string {\n  return messages\n    .map((m) => m.text)\n    .filter(Boolean)\n    .join(\"-\");\n}\n\nlet idCounter = 0;\nfunction nextToolCallId(): string {\n  idCounter += 1;\n  return `fake_tc_${idCounter}`;\n}\n\n/**\n * A fake chat model for testing, created via {@link fakeModel}.\n *\n * Queue responses with `.respond()` and `.respondWithTools()`, then\n * pass the instance directly wherever a chat model is expected.\n * Responses are consumed in first-in-first-out order — one per `invoke()` call.\n * When all queued responses are consumed, further invocations throw.\n */\nexport class FakeBuiltModel extends BaseChatModel {\n  private queue: QueueEntry[] = [];\n\n  private _alwaysThrowError: Error | undefined;\n\n  private _structuredResponseValue: any;\n\n  private _tools: (StructuredTool | ToolSpec)[] = [];\n\n  private _state: FakeModelState = { callIndex: 0, calls: [] };\n\n  /**\n   * All invocations recorded by this model, in order.\n   * Each entry contains the `messages` array and `options` that were\n   * passed to `invoke()`.\n   */\n  get calls(): FakeModelCall[] {\n    return this._state.calls;\n  }\n\n  /**\n   * The number of times this model has been invoked.\n   */\n  get callCount(): number {\n    return this._state.calls.length;\n  }\n\n  constructor() {\n    super({});\n  }\n\n  _llmType(): string {\n    return \"fake-model-builder\";\n  }\n\n  _combineLLMOutput() {\n    return [];\n  }\n\n  /**\n   * Enqueue a response that the model will return on its next invocation.\n   * @param entry A {@link BaseMessage} to return, an `Error` to throw, or\n   *   a factory `(messages) => BaseMessage | Error` for dynamic responses.\n   * @returns `this`, for chaining.\n   */\n  respond(entry: BaseMessage | Error | ResponseFactory): this {\n    if (typeof entry === \"function\") {\n      this.queue.push({ kind: \"factory\", factory: entry });\n    } else if (BaseMessage.isInstance(entry)) {\n      this.queue.push({ kind: \"message\", message: entry });\n    } else {\n      this.queue.push({ kind: \"error\", error: entry });\n    }\n    return this;\n  }\n\n  /**\n   * Enqueue an {@link AIMessage} that carries the given tool calls.\n   * Content is derived from the input messages at invocation time.\n   * @param toolCalls Array of tool calls. Each entry needs `name` and\n   *   `args`; `id` is optional and auto-generated when omitted.\n   * @returns `this`, for chaining.\n   */\n  respondWithTools(\n    toolCalls: Array<{ name: string; args: Record<string, any>; id?: string }>\n  ): this {\n    this.queue.push({\n      kind: \"toolCalls\",\n      toolCalls: toolCalls.map((tc) => ({\n        name: tc.name,\n        args: tc.args,\n        id: tc.id ?? nextToolCallId(),\n        type: \"tool_call\" as const,\n      })),\n    });\n    return this;\n  }\n\n  /**\n   * Make every invocation throw the given error, regardless of the queue.\n   * @param error The error to throw.\n   * @returns `this`, for chaining.\n   */\n  alwaysThrow(error: Error): this {\n    this._alwaysThrowError = error;\n    return this;\n  }\n\n  /**\n   * Set the value that {@link withStructuredOutput} will resolve to.\n   * @param value The structured object to return.\n   * @returns `this`, for chaining.\n   */\n  structuredResponse(value: Record<string, any>): this {\n    this._structuredResponseValue = value;\n    return this;\n  }\n\n  /**\n   * Bind tools to the model. Returns a new model that shares the same\n   * response queue and call history.\n   * @param tools The tools to bind, as {@link StructuredTool} instances or\n   *   plain {@link ToolSpec} objects.\n   * @returns A new RunnableBinding with the tools bound.\n   */\n  bindTools(tools: (StructuredTool | ToolSpec)[]) {\n    const merged = [...this._tools, ...tools];\n    const next = new FakeBuiltModel();\n    next.queue = this.queue;\n    next._alwaysThrowError = this._alwaysThrowError;\n    next._structuredResponseValue = this._structuredResponseValue;\n    next._tools = merged;\n    next._state = this._state;\n\n    return next.withConfig({} as BaseChatModelCallOptions);\n  }\n\n  /**\n   * Returns a {@link Runnable} that produces the {@link structuredResponse}\n   * value. The schema argument is accepted for compatibility but ignored.\n   * @param _params Schema or params (ignored).\n   * @param _config Options (ignored).\n   * @returns A Runnable that resolves to the structured response value.\n   */\n  withStructuredOutput<\n    RunOutput extends Record<string, any> = Record<string, any>,\n  >(\n    _params:\n      | StructuredOutputMethodParams<RunOutput, boolean>\n      | InteropZodType<RunOutput>\n      | Record<string, any>,\n    _config?: StructuredOutputMethodOptions<boolean>\n  ):\n    | Runnable<BaseLanguageModelInput, RunOutput>\n    | Runnable<\n        BaseLanguageModelInput,\n        { raw: BaseMessage; parsed: RunOutput }\n      > {\n    const { _structuredResponseValue } = this;\n    return RunnableLambda.from(async () => {\n      return _structuredResponseValue as RunOutput;\n    }) as Runnable;\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    options?: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    this._state.calls.push({ messages: [...messages], options });\n\n    const currentCallIndex = this._state.callIndex;\n    this._state.callIndex += 1;\n\n    if (this._alwaysThrowError) {\n      throw this._alwaysThrowError;\n    }\n\n    const entry = this.queue[currentCallIndex];\n    if (!entry) {\n      throw new Error(\n        `FakeModel: no response queued for invocation ${currentCallIndex} (${this.queue.length} total queued).`\n      );\n    }\n\n    if (entry.kind === \"error\") {\n      throw entry.error;\n    }\n\n    if (entry.kind === \"factory\") {\n      const result = entry.factory(messages);\n      if (!BaseMessage.isInstance(result)) {\n        throw result;\n      }\n      return {\n        generations: [{ text: \"\", message: result }],\n      };\n    }\n\n    if (entry.kind === \"message\") {\n      return {\n        generations: [{ text: \"\", message: entry.message }],\n      };\n    }\n\n    const content = deriveContent(messages);\n    const message = new AIMessage({\n      content,\n      id: currentCallIndex.toString(),\n      tool_calls:\n        entry.toolCalls.length > 0\n          ? entry.toolCalls.map((tc) => ({\n              ...tc,\n              type: \"tool_call\" as const,\n            }))\n          : undefined,\n    });\n\n    return {\n      generations: [{ text: content, message }],\n      llmOutput: {},\n    };\n  }\n}\n\n/**\n * Creates a new {@link FakeBuiltModel} for testing.\n *\n * Returns a chainable builder — queue responses, then pass the model\n * anywhere a chat model is expected. Responses are consumed in FIFO\n * order, one per `invoke()` call.\n *\n * ## API summary\n *\n * | Method | Description |\n * | --- | --- |\n * | `fakeModel()` | Creates a new fake chat model. Returns a chainable builder. |\n * | `.respond(message)` | Queue an `AIMessage` (or any `BaseMessage`) to return on the next invocation. |\n * | `.respond(error)` | Queue an `Error` to throw on the next invocation. |\n * | `.respond(factory)` | Queue a function `(messages) => BaseMessage \\| Error` for dynamic responses. |\n * | `.respondWithTools(toolCalls)` | Shorthand for `.respond()` with tool calls. Each entry needs `name` and `args`; `id` is optional. |\n * | `.alwaysThrow(error)` | Make every invocation throw this error, regardless of the queue. |\n * | `.structuredResponse(value)` | Set the value returned by `.withStructuredOutput()`. |\n * | `.bindTools(tools)` | Bind tools to the model. Returns a `RunnableBinding` that shares the response queue and call recording. |\n * | `.withStructuredOutput(schema)` | Returns a runnable that produces the `.structuredResponse()` value. |\n * | `.calls` | Array of `{ messages, options }` for every invocation (read-only). |\n * | `.callCount` | Number of times the model has been invoked. |\n *\n * @example\n * ```typescript\n * const model = fakeModel()\n *   .respondWithTools([{ name: \"search\", args: { query: \"weather\" } }])\n *   .respond(new AIMessage(\"Sunny and warm.\"));\n *\n * const r1 = await model.invoke([new HumanMessage(\"What's the weather?\")]);\n * // r1.tool_calls[0].name === \"search\"\n *\n * const r2 = await model.invoke([new HumanMessage(\"Thanks\")]);\n * // r2.content === \"Sunny and warm.\"\n * ```\n */\nexport function fakeModel(): FakeBuiltModel {\n  return new FakeBuiltModel();\n}\n"],"mappings":"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"}
+{"version":3,"file":"fake_model_builder.cjs","names":["BaseChatModel","BaseMessage","RunnableLambda","AIMessage"],"sources":["../../src/testing/fake_model_builder.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport { CallbackManagerForLLMRun } from \"../callbacks/manager.js\";\nimport {\n  BaseChatModel,\n  BaseChatModelCallOptions,\n} from \"../language_models/chat_models.js\";\nimport {\n  BaseLanguageModelInput,\n  StructuredOutputMethodOptions,\n  StructuredOutputMethodParams,\n} from \"../language_models/base.js\";\nimport { BaseMessage, AIMessage } from \"../messages/index.js\";\nimport type { ToolCall } from \"../messages/tool.js\";\nimport type { ChatResult } from \"../outputs.js\";\nimport { Runnable, RunnableLambda } from \"../runnables/base.js\";\nimport { StructuredTool } from \"../tools/index.js\";\nimport type { InteropZodType } from \"../utils/types/zod.js\";\nimport type { ToolSpec } from \"../utils/testing/chat_models.js\";\n\ntype ResponseFactory = (messages: BaseMessage[]) => BaseMessage | Error;\n\ntype QueueEntry =\n  | { kind: \"message\"; message: BaseMessage }\n  | { kind: \"toolCalls\"; toolCalls: ToolCall[] }\n  | { kind: \"error\"; error: Error }\n  | { kind: \"factory\"; factory: ResponseFactory };\n\ninterface FakeModelCall {\n  messages: BaseMessage[];\n  options: any;\n}\n\ninterface FakeModelState {\n  callIndex: number;\n  calls: FakeModelCall[];\n}\n\nfunction deriveContent(messages: BaseMessage[]): string {\n  return messages\n    .map((m) => m.text)\n    .filter(Boolean)\n    .join(\"-\");\n}\n\nlet idCounter = 0;\nfunction nextToolCallId(): string {\n  idCounter += 1;\n  return `fake_tc_${idCounter}`;\n}\n\n/**\n * A fake chat model for testing, created via {@link fakeModel}.\n *\n * Queue responses with `.respond()` and `.respondWithTools()`, then\n * pass the instance directly wherever a chat model is expected.\n * Responses are consumed in first-in-first-out order — one per `invoke()` call.\n * When all queued responses are consumed, further invocations throw.\n */\nexport class FakeBuiltModel extends BaseChatModel {\n  private queue: QueueEntry[] = [];\n\n  private _alwaysThrowError: Error | undefined;\n\n  private _structuredResponseValue: any;\n\n  private _tools: (StructuredTool | ToolSpec)[] = [];\n\n  private _state: FakeModelState = { callIndex: 0, calls: [] };\n\n  /**\n   * All invocations recorded by this model, in order.\n   * Each entry contains the `messages` array and `options` that were\n   * passed to `invoke()`.\n   */\n  get calls(): FakeModelCall[] {\n    return this._state.calls;\n  }\n\n  /**\n   * The number of times this model has been invoked.\n   */\n  get callCount(): number {\n    return this._state.calls.length;\n  }\n\n  constructor() {\n    super({});\n  }\n\n  _llmType(): string {\n    return \"fake-model-builder\";\n  }\n\n  _combineLLMOutput() {\n    return [];\n  }\n\n  /**\n   * Enqueue a response that the model will return on its next invocation.\n   * @param entry A {@link BaseMessage} to return, an `Error` to throw, or\n   *   a factory `(messages) => BaseMessage | Error` for dynamic responses.\n   * @returns `this`, for chaining.\n   */\n  respond(entry: BaseMessage | Error | ResponseFactory): this {\n    if (typeof entry === \"function\") {\n      this.queue.push({ kind: \"factory\", factory: entry });\n    } else if (BaseMessage.isInstance(entry)) {\n      this.queue.push({ kind: \"message\", message: entry });\n    } else {\n      this.queue.push({ kind: \"error\", error: entry });\n    }\n    return this;\n  }\n\n  /**\n   * Enqueue an {@link AIMessage} that carries the given tool calls.\n   * Content is derived from the input messages at invocation time.\n   * @param toolCalls Array of tool calls. Each entry needs `name` and\n   *   `args`; `id` is optional and auto-generated when omitted.\n   * @returns `this`, for chaining.\n   */\n  respondWithTools(\n    toolCalls: Array<{ name: string; args: Record<string, any>; id?: string }>\n  ): this {\n    this.queue.push({\n      kind: \"toolCalls\",\n      toolCalls: toolCalls.map((tc) => ({\n        name: tc.name,\n        args: tc.args,\n        id: tc.id ?? nextToolCallId(),\n        type: \"tool_call\" as const,\n      })),\n    });\n    return this;\n  }\n\n  /**\n   * Make every invocation throw the given error, regardless of the queue.\n   * @param error The error to throw.\n   * @returns `this`, for chaining.\n   */\n  alwaysThrow(error: Error): this {\n    this._alwaysThrowError = error;\n    return this;\n  }\n\n  /**\n   * Set the value that {@link withStructuredOutput} will resolve to.\n   * @param value The structured object to return.\n   * @returns `this`, for chaining.\n   */\n  structuredResponse(value: Record<string, any>): this {\n    this._structuredResponseValue = value;\n    return this;\n  }\n\n  /**\n   * Bind tools to the model. Returns a new model that shares the same\n   * response queue and call history.\n   * @param tools The tools to bind, as {@link StructuredTool} instances or\n   *   plain {@link ToolSpec} objects.\n   * @returns A new RunnableBinding with the tools bound.\n   */\n  bindTools(tools: (StructuredTool | ToolSpec)[]) {\n    const merged = [...this._tools, ...tools];\n    const next = new FakeBuiltModel();\n    next.queue = this.queue;\n    next._alwaysThrowError = this._alwaysThrowError;\n    next._structuredResponseValue = this._structuredResponseValue;\n    next._tools = merged;\n    next._state = this._state;\n\n    return next.withConfig({} as BaseChatModelCallOptions);\n  }\n\n  /**\n   * Returns a {@link Runnable} that produces the {@link structuredResponse}\n   * value. The schema argument is accepted for compatibility but ignored.\n   * @param _params Schema or params (ignored).\n   * @param _config Options (ignored).\n   * @returns A Runnable that resolves to the structured response value.\n   */\n  withStructuredOutput<\n    RunOutput extends Record<string, any> = Record<string, any>,\n  >(\n    _params:\n      | StructuredOutputMethodParams<RunOutput, boolean>\n      | InteropZodType<RunOutput>\n      | Record<string, any>,\n    _config?: StructuredOutputMethodOptions<boolean>\n  ):\n    | Runnable<BaseLanguageModelInput, RunOutput>\n    | Runnable<\n        BaseLanguageModelInput,\n        { raw: BaseMessage; parsed: RunOutput }\n      > {\n    const { _structuredResponseValue } = this;\n    return RunnableLambda.from(async () => {\n      return _structuredResponseValue as RunOutput;\n    }) as Runnable;\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    options?: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    this._state.calls.push({ messages: [...messages], options });\n\n    const currentCallIndex = this._state.callIndex;\n    this._state.callIndex += 1;\n\n    if (this._alwaysThrowError) {\n      throw this._alwaysThrowError;\n    }\n\n    const entry = this.queue[currentCallIndex];\n    if (!entry) {\n      throw new Error(\n        `FakeModel: no response queued for invocation ${currentCallIndex} (${this.queue.length} total queued).`\n      );\n    }\n\n    if (entry.kind === \"error\") {\n      throw entry.error;\n    }\n\n    if (entry.kind === \"factory\") {\n      const result = entry.factory(messages);\n      if (!BaseMessage.isInstance(result)) {\n        throw result;\n      }\n      return {\n        generations: [{ text: \"\", message: result }],\n      };\n    }\n\n    if (entry.kind === \"message\") {\n      return {\n        generations: [{ text: \"\", message: entry.message }],\n      };\n    }\n\n    const content = deriveContent(messages);\n    const message = new AIMessage({\n      content,\n      id: currentCallIndex.toString(),\n      tool_calls:\n        entry.toolCalls.length > 0\n          ? entry.toolCalls.map((tc) => ({\n              ...tc,\n              type: \"tool_call\" as const,\n            }))\n          : undefined,\n    });\n\n    return {\n      generations: [{ text: content, message }],\n      llmOutput: {},\n    };\n  }\n}\n\n/**\n * Creates a new {@link FakeBuiltModel} for testing.\n *\n * Returns a chainable builder — queue responses, then pass the model\n * anywhere a chat model is expected. Responses are consumed in FIFO\n * order, one per `invoke()` call.\n *\n * ## API summary\n *\n * | Method | Description |\n * | --- | --- |\n * | `fakeModel()` | Creates a new fake chat model. Returns a chainable builder. |\n * | `.respond(message)` | Queue an `AIMessage` (or any `BaseMessage`) to return on the next invocation. |\n * | `.respond(error)` | Queue an `Error` to throw on the next invocation. |\n * | `.respond(factory)` | Queue a function `(messages) => BaseMessage \\| Error` for dynamic responses. |\n * | `.respondWithTools(toolCalls)` | Shorthand for `.respond()` with tool calls. Each entry needs `name` and `args`; `id` is optional. |\n * | `.alwaysThrow(error)` | Make every invocation throw this error, regardless of the queue. |\n * | `.structuredResponse(value)` | Set the value returned by `.withStructuredOutput()`. |\n * | `.bindTools(tools)` | Bind tools to the model. Returns a `RunnableBinding` that shares the response queue and call recording. |\n * | `.withStructuredOutput(schema)` | Returns a runnable that produces the `.structuredResponse()` value. |\n * | `.calls` | Array of `{ messages, options }` for every invocation (read-only). |\n * | `.callCount` | Number of times the model has been invoked. |\n *\n * @example\n * ```typescript\n * const model = fakeModel()\n *   .respondWithTools([{ name: \"search\", args: { query: \"weather\" } }])\n *   .respond(new AIMessage(\"Sunny and warm.\"));\n *\n * const r1 = await model.invoke([new HumanMessage(\"What's the weather?\")]);\n * // r1.tool_calls[0].name === \"search\"\n *\n * const r2 = await model.invoke([new HumanMessage(\"Thanks\")]);\n * // r2.content === \"Sunny and warm.\"\n * ```\n */\nexport function fakeModel(): FakeBuiltModel {\n  return new FakeBuiltModel();\n}\n"],"mappings":"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"}