@langchain/core 0.3.72 → 1.0.0-alpha.2

package/dist/stores.js

@@ -1,85 +1,74 @@
+import { __export } from "./_virtual/rolldown_runtime.js";
 import { Serializable } from "./load/serializable.js";
+
+//#region src/stores.ts
+var stores_exports = {};
+__export(stores_exports, {
+	BaseStore: () => BaseStore,
+	InMemoryStore: () => InMemoryStore
+});
 /**
- * Abstract interface for a key-value store.
- */
-export class BaseStore extends Serializable {
-}
+* Abstract interface for a key-value store.
+*/
+var BaseStore = class extends Serializable {};
 /**
- * In-memory implementation of the BaseStore using a dictionary. Used for
- * storing key-value pairs in memory.
- * @example
- * ```typescript
- * const store = new InMemoryStore<BaseMessage>();
- * await store.mset(
- *   Array.from({ length: 5 }).map((_, index) => [
- *     `message:id:${index}`,
- *     index % 2 === 0
- *       ? new AIMessage("ai stuff...")
- *       : new HumanMessage("human stuff..."),
- *   ]),
- * );
- *
- * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
- * await store.mdelete(await store.yieldKeys("message:id:").toArray());
- * ```
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export class InMemoryStore extends BaseStore {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "storage"]
-        });
-        Object.defineProperty(this, "store", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-    }
-    /**
-     * Retrieves the values associated with the given keys from the store.
-     * @param keys Keys to retrieve values for.
-     * @returns Array of values associated with the given keys.
-     */
-    async mget(keys) {
-        return keys.map((key) => this.store[key]);
-    }
-    /**
-     * Sets the values for the given keys in the store.
-     * @param keyValuePairs Array of key-value pairs to set in the store.
-     * @returns Promise that resolves when all key-value pairs have been set.
-     */
-    async mset(keyValuePairs) {
-        for (const [key, value] of keyValuePairs) {
-            this.store[key] = value;
-        }
-    }
-    /**
-     * Deletes the given keys and their associated values from the store.
-     * @param keys Keys to delete from the store.
-     * @returns Promise that resolves when all keys have been deleted.
-     */
-    async mdelete(keys) {
-        for (const key of keys) {
-            delete this.store[key];
-        }
-    }
-    /**
-     * Asynchronous generator that yields keys from the store. If a prefix is
-     * provided, it only yields keys that start with the prefix.
-     * @param prefix Optional prefix to filter keys.
-     * @returns AsyncGenerator that yields keys from the store.
-     */
-    async *yieldKeys(prefix) {
-        const keys = Object.keys(this.store);
-        for (const key of keys) {
-            if (prefix === undefined || key.startsWith(prefix)) {
-                yield key;
-            }
-        }
-    }
-}
+* In-memory implementation of the BaseStore using a dictionary. Used for
+* storing key-value pairs in memory.
+* @example
+* ```typescript
+* const store = new InMemoryStore<BaseMessage>();
+* await store.mset(
+*   Array.from({ length: 5 }).map((_, index) => [
+*     `message:id:${index}`,
+*     index % 2 === 0
+*       ? new AIMessage("ai stuff...")
+*       : new HumanMessage("human stuff..."),
+*   ]),
+* );
+*
+* const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+* await store.mdelete(await store.yieldKeys("message:id:").toArray());
+* ```
+*/
+var InMemoryStore = class extends BaseStore {
+	lc_namespace = ["langchain", "storage"];
+	store = {};
+	/**
+	* Retrieves the values associated with the given keys from the store.
+	* @param keys Keys to retrieve values for.
+	* @returns Array of values associated with the given keys.
+	*/
+	async mget(keys) {
+		return keys.map((key) => this.store[key]);
+	}
+	/**
+	* Sets the values for the given keys in the store.
+	* @param keyValuePairs Array of key-value pairs to set in the store.
+	* @returns Promise that resolves when all key-value pairs have been set.
+	*/
+	async mset(keyValuePairs) {
+		for (const [key, value] of keyValuePairs) this.store[key] = value;
+	}
+	/**
+	* Deletes the given keys and their associated values from the store.
+	* @param keys Keys to delete from the store.
+	* @returns Promise that resolves when all keys have been deleted.
+	*/
+	async mdelete(keys) {
+		for (const key of keys) delete this.store[key];
+	}
+	/**
+	* Asynchronous generator that yields keys from the store. If a prefix is
+	* provided, it only yields keys that start with the prefix.
+	* @param prefix Optional prefix to filter keys.
+	* @returns AsyncGenerator that yields keys from the store.
+	*/
+	async *yieldKeys(prefix) {
+		const keys = Object.keys(this.store);
+		for (const key of keys) if (prefix === void 0 || key.startsWith(prefix)) yield key;
+	}
+};
+
+//#endregion
+export { BaseStore, InMemoryStore, stores_exports };
+//# sourceMappingURL=stores.js.map

package/dist/stores.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stores.js","names":["keys: string[]","keyValuePairs: [string, T][]","prefix?: string | undefined"],"sources":["../src/stores.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n\n/** @deprecated For backwards compatibility only. Remove on next minor version upgrade. */\nexport interface BaseStoreInterface<K, V> {\n  /**\n   * Method to get multiple values for a set of keys.\n   * @param {K[]} keys - An array of keys.\n   * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n   */\n  mget(keys: K[]): Promise<(V | undefined)[]>;\n\n  /**\n   * Method to set a value for multiple keys.\n   * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  mset(keyValuePairs: [K, V][]): Promise<void>;\n\n  /**\n   * Method to delete multiple keys.\n   * @param {K[]} keys - An array of keys to delete.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  mdelete(keys: K[]): Promise<void>;\n\n  /**\n   * Method to yield keys optionally based on a prefix.\n   * @param {string} prefix - Optional prefix to filter keys.\n   * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n   */\n  yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n\n/**\n * Abstract interface for a key-value store.\n */\nexport abstract class BaseStore<K, V>\n  extends Serializable\n  implements BaseStoreInterface<K, V>\n{\n  /**\n   * Abstract method to get multiple values for a set of keys.\n   * @param {K[]} keys - An array of keys.\n   * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n   */\n  abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n\n  /**\n   * Abstract method to set a value for multiple keys.\n   * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n\n  /**\n   * Abstract method to delete multiple keys.\n   * @param {K[]} keys - An array of keys to delete.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mdelete(keys: K[]): Promise<void>;\n\n  /**\n   * Abstract method to yield keys optionally based on a prefix.\n   * @param {string} prefix - Optional prefix to filter keys.\n   * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n   */\n  abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class InMemoryStore<T = any> extends BaseStore<string, T> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  protected store: Record<string, T> = {};\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    return keys.map((key) => this.store[key]);\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, T][]): Promise<void> {\n    for (const [key, value] of keyValuePairs) {\n      this.store[key] = value;\n    }\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    for (const key of keys) {\n      delete this.store[key];\n    }\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string | undefined): AsyncGenerator<string> {\n    const keys = Object.keys(this.store);\n    for (const key of keys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAoCA,IAAsB,YAAtB,cACU,aAEV,CA4BC;;;;;;;;;;;;;;;;;;;;AAsBD,IAAa,gBAAb,cAA4C,UAAqB;CAC/D,eAAe,CAAC,aAAa,SAAU;CAEvC,AAAU,QAA2B,CAAE;;;;;;CAOvC,MAAM,KAAKA,MAAgB;AACzB,SAAO,KAAK,IAAI,CAAC,QAAQ,KAAK,MAAM,KAAK;CAC1C;;;;;;CAOD,MAAM,KAAKC,eAA6C;AACtD,OAAK,MAAM,CAAC,KAAK,MAAM,IAAI,eACzB,KAAK,MAAM,OAAO;CAErB;;;;;;CAOD,MAAM,QAAQD,MAA+B;AAC3C,OAAK,MAAM,OAAO,MAChB,OAAO,KAAK,MAAM;CAErB;;;;;;;CAQD,OAAO,UAAUE,QAAqD;EACpE,MAAM,OAAO,OAAO,KAAK,KAAK,MAAM;AACpC,OAAK,MAAM,OAAO,KAChB,KAAI,WAAW,UAAa,IAAI,WAAW,OAAO,EAChD,MAAM;CAGX;AACF"}

package/dist/structured_query/base.cjs

@@ -1,139 +1,89 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BasicTranslator = exports.BaseTranslator = void 0;
-const ir_js_1 = require("./ir.cjs");
-const utils_js_1 = require("./utils.cjs");
+const require_ir = require('./ir.cjs');
+const require_utils = require('./utils.cjs');
+
+//#region src/structured_query/base.ts
 /**
- * Abstract class that provides a blueprint for creating specific
- * translator classes. Defines two abstract methods: formatFunction and
- * mergeFilters.
- */
-class BaseTranslator extends ir_js_1.Visitor {
-}
-exports.BaseTranslator = BaseTranslator;
+* Abstract class that provides a blueprint for creating specific
+* translator classes. Defines two abstract methods: formatFunction and
+* mergeFilters.
+*/
+var BaseTranslator = class extends require_ir.Visitor {};
 /**
- * Class that extends the BaseTranslator class and provides concrete
- * implementations for the abstract methods. Also declares three types:
- * VisitOperationOutput, VisitComparisonOutput, and
- * VisitStructuredQueryOutput, which are used as the return types for the
- * visitOperation, visitComparison, and visitStructuredQuery methods
- * respectively.
- */
-class BasicTranslator extends BaseTranslator {
-    constructor(opts) {
-        super();
-        Object.defineProperty(this, "allowedOperators", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "allowedComparators", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.allowedOperators = opts?.allowedOperators ?? [
-            ir_js_1.Operators.and,
-            ir_js_1.Operators.or,
-        ];
-        this.allowedComparators = opts?.allowedComparators ?? [
-            ir_js_1.Comparators.eq,
-            ir_js_1.Comparators.ne,
-            ir_js_1.Comparators.gt,
-            ir_js_1.Comparators.gte,
-            ir_js_1.Comparators.lt,
-            ir_js_1.Comparators.lte,
-        ];
-    }
-    formatFunction(func) {
-        if (func in ir_js_1.Comparators) {
-            if (this.allowedComparators.length > 0 &&
-                this.allowedComparators.indexOf(func) === -1) {
-                throw new Error(`Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(", ")}`);
-            }
-        }
-        else if (func in ir_js_1.Operators) {
-            if (this.allowedOperators.length > 0 &&
-                this.allowedOperators.indexOf(func) === -1) {
-                throw new Error(`Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(", ")}`);
-            }
-        }
-        else {
-            throw new Error("Unknown comparator or operator");
-        }
-        return `$${func}`;
-    }
-    /**
-     * Visits an operation and returns a result.
-     * @param operation The operation to visit.
-     * @returns The result of visiting the operation.
-     */
-    visitOperation(operation) {
-        const args = operation.args?.map((arg) => arg.accept(this));
-        return {
-            [this.formatFunction(operation.operator)]: args,
-        };
-    }
-    /**
-     * Visits a comparison and returns a result.
-     * @param comparison The comparison to visit.
-     * @returns The result of visiting the comparison.
-     */
-    visitComparison(comparison) {
-        return {
-            [comparison.attribute]: {
-                [this.formatFunction(comparison.comparator)]: (0, utils_js_1.castValue)(comparison.value),
-            },
-        };
-    }
-    /**
-     * Visits a structured query and returns a result.
-     * @param query The structured query to visit.
-     * @returns The result of visiting the structured query.
-     */
-    visitStructuredQuery(query) {
-        let nextArg = {};
-        if (query.filter) {
-            nextArg = {
-                filter: query.filter.accept(this),
-            };
-        }
-        return nextArg;
-    }
-    mergeFilters(defaultFilter, generatedFilter, mergeType = "and", forceDefaultFilter = false) {
-        if ((0, utils_js_1.isFilterEmpty)(defaultFilter) && (0, utils_js_1.isFilterEmpty)(generatedFilter)) {
-            return undefined;
-        }
-        if ((0, utils_js_1.isFilterEmpty)(defaultFilter) || mergeType === "replace") {
-            if ((0, utils_js_1.isFilterEmpty)(generatedFilter)) {
-                return undefined;
-            }
-            return generatedFilter;
-        }
-        if ((0, utils_js_1.isFilterEmpty)(generatedFilter)) {
-            if (forceDefaultFilter) {
-                return defaultFilter;
-            }
-            if (mergeType === "and") {
-                return undefined;
-            }
-            return defaultFilter;
-        }
-        if (mergeType === "and") {
-            return {
-                $and: [defaultFilter, generatedFilter],
-            };
-        }
-        else if (mergeType === "or") {
-            return {
-                $or: [defaultFilter, generatedFilter],
-            };
-        }
-        else {
-            throw new Error("Unknown merge type");
-        }
-    }
-}
+* Class that extends the BaseTranslator class and provides concrete
+* implementations for the abstract methods. Also declares three types:
+* VisitOperationOutput, VisitComparisonOutput, and
+* VisitStructuredQueryOutput, which are used as the return types for the
+* visitOperation, visitComparison, and visitStructuredQuery methods
+* respectively.
+*/
+var BasicTranslator = class extends BaseTranslator {
+	allowedOperators;
+	allowedComparators;
+	constructor(opts) {
+		super();
+		this.allowedOperators = opts?.allowedOperators ?? [require_ir.Operators.and, require_ir.Operators.or];
+		this.allowedComparators = opts?.allowedComparators ?? [
+			require_ir.Comparators.eq,
+			require_ir.Comparators.ne,
+			require_ir.Comparators.gt,
+			require_ir.Comparators.gte,
+			require_ir.Comparators.lt,
+			require_ir.Comparators.lte
+		];
+	}
+	formatFunction(func) {
+		if (func in require_ir.Comparators) {
+			if (this.allowedComparators.length > 0 && this.allowedComparators.indexOf(func) === -1) throw new Error(`Comparator ${func} not allowed. Allowed comparators: ${this.allowedComparators.join(", ")}`);
+		} else if (func in require_ir.Operators) {
+			if (this.allowedOperators.length > 0 && this.allowedOperators.indexOf(func) === -1) throw new Error(`Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(", ")}`);
+		} else throw new Error("Unknown comparator or operator");
+		return `$${func}`;
+	}
+	/**
+	* Visits an operation and returns a result.
+	* @param operation The operation to visit.
+	* @returns The result of visiting the operation.
+	*/
+	visitOperation(operation) {
+		const args = operation.args?.map((arg) => arg.accept(this));
+		return { [this.formatFunction(operation.operator)]: args };
+	}
+	/**
+	* Visits a comparison and returns a result.
+	* @param comparison The comparison to visit.
+	* @returns The result of visiting the comparison.
+	*/
+	visitComparison(comparison) {
+		return { [comparison.attribute]: { [this.formatFunction(comparison.comparator)]: require_utils.castValue(comparison.value) } };
+	}
+	/**
+	* Visits a structured query and returns a result.
+	* @param query The structured query to visit.
+	* @returns The result of visiting the structured query.
+	*/
+	visitStructuredQuery(query) {
+		let nextArg = {};
+		if (query.filter) nextArg = { filter: query.filter.accept(this) };
+		return nextArg;
+	}
+	mergeFilters(defaultFilter, generatedFilter, mergeType = "and", forceDefaultFilter = false) {
+		if (require_utils.isFilterEmpty(defaultFilter) && require_utils.isFilterEmpty(generatedFilter)) return void 0;
+		if (require_utils.isFilterEmpty(defaultFilter) || mergeType === "replace") {
+			if (require_utils.isFilterEmpty(generatedFilter)) return void 0;
+			return generatedFilter;
+		}
+		if (require_utils.isFilterEmpty(generatedFilter)) {
+			if (forceDefaultFilter) return defaultFilter;
+			if (mergeType === "and") return void 0;
+			return defaultFilter;
+		}
+		if (mergeType === "and") return { $and: [defaultFilter, generatedFilter] };
+		else if (mergeType === "or") return { $or: [defaultFilter, generatedFilter] };
+		else throw new Error("Unknown merge type");
+	}
+};
+
+//#endregion
+exports.BaseTranslator = BaseTranslator;
 exports.BasicTranslator = BasicTranslator;
+//# sourceMappingURL=base.cjs.map

package/dist/structured_query/base.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.cjs","names":["Visitor","opts?: TranslatorOpts","Operators","Comparators","func: Operator | Comparator","operation: Operation","comparison: Comparison","castValue","query: StructuredQuery","defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined","generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined","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,mBAAW,CAuBpB;;;;;;;;;AAUD,IAAa,kBAAb,cAEU,eAAkB;CAO1B;CAEA;CAEA,YAAYC,MAAuB;EACjC,OAAO;EACP,KAAK,mBAAmB,MAAM,oBAAoB,CAChDC,qBAAU,KACVA,qBAAU,EACX;EACD,KAAK,qBAAqB,MAAM,sBAAsB;GACpDC,uBAAY;GACZA,uBAAY;GACZA,uBAAY;GACZA,uBAAY;GACZA,uBAAY;GACZA,uBAAY;EACb;CACF;CAED,eAAeC,MAAqC;AAClD,MAAI,QAAQD,wBACV;OACE,KAAK,mBAAmB,SAAS,KACjC,KAAK,mBAAmB,QAAQ,KAAmB,KAAK,GAExD,OAAM,IAAI,MACR,CAAC,WAAW,EAAE,KAAK,mCAAmC,EAAE,KAAK,mBAAmB,KAC9E,KACD,EAAE;EAEN,WACQ,QAAQD,sBACjB;OACE,KAAK,iBAAiB,SAAS,KAC/B,KAAK,iBAAiB,QAAQ,KAAiB,KAAK,GAEpD,OAAM,IAAI,MACR,CAAC,SAAS,EAAE,KAAK,iCAAiC,EAAE,KAAK,iBAAiB,KACxE,KACD,EAAE;EAEN,MAED,OAAM,IAAI,MAAM;AAElB,SAAO,CAAC,CAAC,EAAE,MAAM;CAClB;;;;;;CAOD,eAAeG,WAAoD;EACjE,MAAM,OAAO,UAAU,MAAM,IAAI,CAAC,QAChC,IAAI,OAAO,KAAK,CACjB;AACD,SAAO,GACJ,KAAK,eAAe,UAAU,SAAS,GAAG,KAC5C;CACF;;;;;;CAOD,gBAAgBC,YAAuD;AACrE,SAAO,GACJ,WAAW,YAAY,GACrB,KAAK,eAAe,WAAW,WAAW,GAAGC,wBAC5C,WAAW,MACZ,CACF,EACF;CACF;;;;;;CAOD,qBACEC,OACoC;EACpC,IAAI,UAAU,CAAE;AAChB,MAAI,MAAM,QACR,UAAU,EACR,QAAQ,MAAM,OAAO,OAAO,KAAK,CAClC;AAEH,SAAO;CACR;CAED,aACEC,eACAC,iBACA,YAAY,OACZ,qBAAqB,OAC+B;AACpD,MAAIC,4BAAc,cAAc,IAAIA,4BAAc,gBAAgB,CAChE,QAAO;AAET,MAAIA,4BAAc,cAAc,IAAI,cAAc,WAAW;AAC3D,OAAIA,4BAAc,gBAAgB,CAChC,QAAO;AAET,UAAO;EACR;AACD,MAAIA,4BAAc,gBAAgB,EAAE;AAClC,OAAI,mBACF,QAAO;AAET,OAAI,cAAc,MAChB,QAAO;AAET,UAAO;EACR;AACD,MAAI,cAAc,MAChB,QAAO,EACL,MAAM,CAAC,eAAe,eAAgB,EACvC;WACQ,cAAc,KACvB,QAAO,EACL,KAAK,CAAC,eAAe,eAAgB,EACtC;MAED,OAAM,IAAI,MAAM;CAEnB;AACF"}

package/dist/structured_query/base.d.cts

@@ -0,0 +1,75 @@
+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
+ * operators and comparators.
+ */
+type TranslatorOpts = {
+  allowedOperators: Operator[];
+  allowedComparators: Comparator[];
+};
+/**
+ * Abstract class that provides a blueprint for creating specific
+ * translator classes. Defines two abstract methods: formatFunction and
+ * mergeFilters.
+ */
+declare abstract class BaseTranslator<T extends VectorStore = VectorStore> extends Visitor<T> {
+  /**
+   * Formats a given function (either an operator or a comparator) into a
+   * string.
+   * @param func The function to format.
+   * @returns Formatted string representation of the function.
+   */
+  abstract formatFunction(func: Operator | Comparator): string;
+  /**
+   * Merges two filters into one, using a specified merge type.
+   * @param defaultFilter The default filter.
+   * @param generatedFilter The generated filter.
+   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.
+   * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.
+   * @returns The merged filter, or undefined if both filters are empty.
+   */
+  abstract mergeFilters(defaultFilter: this["VisitStructuredQueryOutput"]["filter"] | undefined, generatedFilter: this["VisitStructuredQueryOutput"]["filter"] | undefined, mergeType?: "and" | "or" | "replace", forceDefaultFilter?: boolean): this["VisitStructuredQueryOutput"]["filter"] | undefined;
+}
+/**
+ * Class that extends the BaseTranslator class and provides concrete
+ * implementations for the abstract methods. Also declares three types:
+ * VisitOperationOutput, VisitComparisonOutput, and
+ * VisitStructuredQueryOutput, which are used as the return types for the
+ * visitOperation, visitComparison, and visitStructuredQuery methods
+ * respectively.
+ */
+declare class BasicTranslator<T extends VectorStore = VectorStore> extends BaseTranslator<T> {
+  VisitOperationOutput: VisitorOperationResult;
+  VisitComparisonOutput: VisitorComparisonResult;
+  VisitStructuredQueryOutput: VisitorStructuredQueryResult;
+  allowedOperators: Operator[];
+  allowedComparators: Comparator[];
+  constructor(opts?: TranslatorOpts);
+  formatFunction(func: Operator | Comparator): string;
+  /**
+   * Visits an operation and returns a result.
+   * @param operation The operation to visit.
+   * @returns The result of visiting the operation.
+   */
+  visitOperation(operation: Operation): this["VisitOperationOutput"];
+  /**
+   * Visits a comparison and returns a result.
+   * @param comparison The comparison to visit.
+   * @returns The result of visiting the comparison.
+   */
+  visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
+  /**
+   * Visits a structured query and returns a result.
+   * @param query The structured query to visit.
+   * @returns The result of visiting the structured query.
+   */
+  visitStructuredQuery(query: StructuredQuery): this["VisitStructuredQueryOutput"];
+  mergeFilters(defaultFilter: VisitorStructuredQueryResult["filter"] | undefined, generatedFilter: VisitorStructuredQueryResult["filter"] | undefined, mergeType?: string, forceDefaultFilter?: boolean): VisitorStructuredQueryResult["filter"] | undefined;
+}
+//#endregion
+export { BaseTranslator, BasicTranslator, TranslatorOpts };
+//# sourceMappingURL=base.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":["VectorStore","Comparator","Comparison","Operation","Operator","StructuredQuery","Visitor","VisitorComparisonResult","VisitorOperationResult","VisitorStructuredQueryResult","TranslatorOpts","BaseTranslator","T","BasicTranslator"],"sources":["../../src/structured_query/base.d.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport { Comparator, Comparison, Operation, Operator, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorStructuredQueryResult } from \"./ir.js\";\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 * Abstract class that provides a blueprint for creating specific\n * translator classes. Defines two abstract methods: formatFunction and\n * mergeFilters.\n */\nexport declare abstract class BaseTranslator<T extends VectorStore = VectorStore> 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     * 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(defaultFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined, generatedFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined, mergeType?: \"and\" | \"or\" | \"replace\", forceDefaultFilter?: boolean): this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined;\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 declare class BasicTranslator<T extends VectorStore = VectorStore> extends BaseTranslator<T> {\n    VisitOperationOutput: VisitorOperationResult;\n    VisitComparisonOutput: VisitorComparisonResult;\n    VisitStructuredQueryOutput: VisitorStructuredQueryResult;\n    allowedOperators: Operator[];\n    allowedComparators: Comparator[];\n    constructor(opts?: TranslatorOpts);\n    formatFunction(func: Operator | Comparator): string;\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    /**\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    /**\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(query: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n    mergeFilters(defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined, generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined, mergeType?: string, forceDefaultFilter?: boolean): VisitorStructuredQueryResult[\"filter\"] | undefined;\n}\n"],"mappings":";;;;;;;AAMA;;AACsBI,KADVM,cAAAA,GACUN;EAAQ,gBACNH,EADFG,QACEH,EAAAA;EAAU,kBAAA,EAAVA,UAAU,EAAA;AAOlC,CAAA;;;;;;AAO6CA,uBAPfU,cAOeV,CAAAA,UAPUD,WAOVC,GAPwBD,WAOxBC,CAAAA,SAP6CK,OAO7CL,CAPqDW,CAOrDX,CAAAA,CAAAA;EAAU;AAP0C;AA0BjG;;;;EAAwE,SAAyBW,cAAAA,CAAAA,IAAAA,EAnB/DR,QAmB+DQ,GAnBpDX,UAmBoDW,CAAAA,EAAAA,MAAAA;EAAC;;;;;;;;EAOpD,SAMhBT,YAAAA,CAAAA,aAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA,EAAAA,eAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA,EAAAA,SAAAA,CAAAA,EAAAA,KAAAA,GAAAA,IAAAA,GAAAA,SAAAA,EAAAA,kBAAAA,CAAAA,EAAAA,OAAAA,CAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA;;;;;;;AAbkE;;;cAA3EU,0BAA0Bb,cAAcA,qBAAqBW,eAAeC;wBACvEJ;yBACCD;8BACKE;oBACVL;sBACEH;qBACDS;uBACEN,WAAWH;;;;;;4BAMNE;;;;;;8BAMED;;;;;;8BAMAG;8BACAI,qEAAqEA,uGAAuGA"}

package/dist/structured_query/base.d.ts

@@ -1,35 +1,38 @@
 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
  * operators and comparators.
  */
-export type TranslatorOpts = {
-    allowedOperators: Operator[];
-    allowedComparators: Comparator[];
+type TranslatorOpts = {
+  allowedOperators: Operator[];
+  allowedComparators: Comparator[];
 };
 /**
  * Abstract class that provides a blueprint for creating specific
  * translator classes. Defines two abstract methods: formatFunction and
  * mergeFilters.
  */
-export declare abstract class BaseTranslator<T extends VectorStore = VectorStore> extends Visitor<T> {
-    /**
-     * Formats a given function (either an operator or a comparator) into a
-     * string.
-     * @param func The function to format.
-     * @returns Formatted string representation of the function.
-     */
-    abstract formatFunction(func: Operator | Comparator): string;
-    /**
-     * Merges two filters into one, using a specified merge type.
-     * @param defaultFilter The default filter.
-     * @param generatedFilter The generated filter.
-     * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.
-     * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.
-     * @returns The merged filter, or undefined if both filters are empty.
-     */
-    abstract mergeFilters(defaultFilter: this["VisitStructuredQueryOutput"]["filter"] | undefined, generatedFilter: this["VisitStructuredQueryOutput"]["filter"] | undefined, mergeType?: "and" | "or" | "replace", forceDefaultFilter?: boolean): this["VisitStructuredQueryOutput"]["filter"] | undefined;
+declare abstract class BaseTranslator<T extends VectorStore = VectorStore> extends Visitor<T> {
+  /**
+   * Formats a given function (either an operator or a comparator) into a
+   * string.
+   * @param func The function to format.
+   * @returns Formatted string representation of the function.
+   */
+  abstract formatFunction(func: Operator | Comparator): string;
+  /**
+   * Merges two filters into one, using a specified merge type.
+   * @param defaultFilter The default filter.
+   * @param generatedFilter The generated filter.
+   * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.
+   * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.
+   * @returns The merged filter, or undefined if both filters are empty.
+   */
+  abstract mergeFilters(defaultFilter: this["VisitStructuredQueryOutput"]["filter"] | undefined, generatedFilter: this["VisitStructuredQueryOutput"]["filter"] | undefined, mergeType?: "and" | "or" | "replace", forceDefaultFilter?: boolean): this["VisitStructuredQueryOutput"]["filter"] | undefined;
 }
 /**
  * Class that extends the BaseTranslator class and provides concrete
@@ -39,31 +42,34 @@ export declare abstract class BaseTranslator<T extends VectorStore = VectorStore
  * visitOperation, visitComparison, and visitStructuredQuery methods
  * respectively.
  */
-export declare class BasicTranslator<T extends VectorStore = VectorStore> extends BaseTranslator<T> {
-    VisitOperationOutput: VisitorOperationResult;
-    VisitComparisonOutput: VisitorComparisonResult;
-    VisitStructuredQueryOutput: VisitorStructuredQueryResult;
-    allowedOperators: Operator[];
-    allowedComparators: Comparator[];
-    constructor(opts?: TranslatorOpts);
-    formatFunction(func: Operator | Comparator): string;
-    /**
-     * Visits an operation and returns a result.
-     * @param operation The operation to visit.
-     * @returns The result of visiting the operation.
-     */
-    visitOperation(operation: Operation): this["VisitOperationOutput"];
-    /**
-     * Visits a comparison and returns a result.
-     * @param comparison The comparison to visit.
-     * @returns The result of visiting the comparison.
-     */
-    visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
-    /**
-     * Visits a structured query and returns a result.
-     * @param query The structured query to visit.
-     * @returns The result of visiting the structured query.
-     */
-    visitStructuredQuery(query: StructuredQuery): this["VisitStructuredQueryOutput"];
-    mergeFilters(defaultFilter: VisitorStructuredQueryResult["filter"] | undefined, generatedFilter: VisitorStructuredQueryResult["filter"] | undefined, mergeType?: string, forceDefaultFilter?: boolean): VisitorStructuredQueryResult["filter"] | undefined;
+declare class BasicTranslator<T extends VectorStore = VectorStore> extends BaseTranslator<T> {
+  VisitOperationOutput: VisitorOperationResult;
+  VisitComparisonOutput: VisitorComparisonResult;
+  VisitStructuredQueryOutput: VisitorStructuredQueryResult;
+  allowedOperators: Operator[];
+  allowedComparators: Comparator[];
+  constructor(opts?: TranslatorOpts);
+  formatFunction(func: Operator | Comparator): string;
+  /**
+   * Visits an operation and returns a result.
+   * @param operation The operation to visit.
+   * @returns The result of visiting the operation.
+   */
+  visitOperation(operation: Operation): this["VisitOperationOutput"];
+  /**
+   * Visits a comparison and returns a result.
+   * @param comparison The comparison to visit.
+   * @returns The result of visiting the comparison.
+   */
+  visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
+  /**
+   * Visits a structured query and returns a result.
+   * @param query The structured query to visit.
+   * @returns The result of visiting the structured query.
+   */
+  visitStructuredQuery(query: StructuredQuery): this["VisitStructuredQueryOutput"];
+  mergeFilters(defaultFilter: VisitorStructuredQueryResult["filter"] | undefined, generatedFilter: VisitorStructuredQueryResult["filter"] | undefined, mergeType?: string, forceDefaultFilter?: boolean): VisitorStructuredQueryResult["filter"] | undefined;
 }
+//#endregion
+export { BaseTranslator, BasicTranslator, TranslatorOpts };
+//# sourceMappingURL=base.d.ts.map