@react-querybuilder/core 8.16.0 → 8.16.2

package/dist/convertQuery-BeJJH9BI.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"convertQuery-BeJJH9BI.mjs","names":[],"sources":["../src/utils/convertQuery.ts"],"sourcesContent":["import type {\n  RuleGroupArray,\n  RuleGroupICArray,\n  RuleGroupType,\n  RuleGroupTypeAny,\n  RuleGroupTypeIC,\n  RuleType,\n  ToRuleGroupType,\n  ToRuleGroupTypeIC,\n} from '../types';\nimport { isRuleGroup, isRuleGroupType, isRuleGroupTypeIC } from './isRuleGroup';\nimport { lc } from './misc';\n\nconst combinatorLevels = ['or', 'xor', 'and'] as const;\n\nconst isSameString = (a: unknown, b: string) => lc(a) === b;\n\nconst generateRuleGroupICWithConsistentCombinators = (\n  rg: RuleGroupTypeIC,\n  baseCombinatorLevel: number = 0\n): RuleGroupTypeIC => {\n  const baseCombinator = combinatorLevels[baseCombinatorLevel];\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  if (!rg.rules.includes(baseCombinator as any)) {\n    // No instances of this combinator, so group based on the next\n    // combinator level if at least two levels remain\n    return baseCombinatorLevel < combinatorLevels.length - 2\n      ? generateRuleGroupICWithConsistentCombinators(rg, baseCombinatorLevel + 1)\n      : rg;\n  }\n\n  const newRules = [...rg.rules] as RuleGroupICArray;\n  let cursor = 0;\n\n  // Group all chains of combinators in the rule array that are not the base combinator\n  while (cursor < newRules.length - 2) {\n    if (isSameString(newRules[cursor + 1], baseCombinator)) {\n      cursor += 2;\n      continue;\n    }\n\n    let nextBaseCombinatorIndex = -1;\n    for (let i = cursor + 2; i < newRules.length; i++) {\n      if (typeof newRules[i] === 'string' && lc(newRules[i]) === baseCombinator) {\n        nextBaseCombinatorIndex = i;\n        break;\n      }\n    }\n\n    if (nextBaseCombinatorIndex === -1) {\n      // No more instances of this combinator, so group all remaining rules and exit the loop\n      newRules.splice(\n        cursor,\n        newRules.length,\n        generateRuleGroupICWithConsistentCombinators(\n          // oxlint-disable-next-line typescript/no-explicit-any\n          { rules: newRules.slice(cursor) as any },\n          baseCombinatorLevel + 1\n        )\n      );\n      break;\n    } else {\n      // Group all rules between the current cursor and the next instance of the base combinator\n      newRules.splice(\n        cursor,\n        nextBaseCombinatorIndex - cursor,\n        generateRuleGroupICWithConsistentCombinators(\n          // oxlint-disable-next-line typescript/no-explicit-any\n          { rules: newRules.slice(cursor, nextBaseCombinatorIndex) as any },\n          baseCombinatorLevel + 1\n        )\n      );\n    }\n  }\n\n  return { ...rg, rules: newRules };\n};\n\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}.\n *\n * This function is idempotent: {@link RuleGroupType} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertFromIC = <RG extends RuleGroupTypeAny>(rg: RG): ToRuleGroupType<RG> => {\n  if (isRuleGroupType(rg)) {\n    return rg as ToRuleGroupType<RG>;\n  }\n  const processedRG = generateRuleGroupICWithConsistentCombinators(rg);\n  const rules: RuleGroupArray = [];\n  let combinator = 'and';\n  for (const [idx, r] of processedRG.rules.entries()) {\n    if (typeof r === 'string') {\n      if (idx === 1) combinator = r;\n    } else {\n      rules.push(isRuleGroup(r) ? convertFromIC(r) : r);\n    }\n  }\n  return { ...processedRG, combinator, rules } as ToRuleGroupType<RG>;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}.\n *\n * This function is idempotent: {@link RuleGroupTypeIC} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertToIC = <RG extends RuleGroupTypeAny>(rg: RG): ToRuleGroupTypeIC<RG> => {\n  if (isRuleGroupTypeIC(rg)) {\n    return rg as ToRuleGroupTypeIC<RG>;\n  }\n  const { combinator, ...queryWithoutCombinator } = rg;\n  const rules: (RuleGroupTypeIC | RuleType | string)[] = [];\n  const { length } = rg.rules;\n  for (let idx = 0; idx < length; idx++) {\n    const r = rg.rules[idx];\n    if (isRuleGroup(r)) {\n      rules.push(convertToIC(r));\n    } else {\n      rules.push(r);\n    }\n    if (combinator && idx < length - 1) {\n      rules.push(combinator);\n    }\n  }\n  return { ...queryWithoutCombinator, rules } as ToRuleGroupTypeIC<RG>;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}. For a more explicit\n * operation, use {@link convertToIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupType): RuleGroupTypeIC;\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}. For a more explicit\n * operation, use {@link convertFromIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupTypeIC): RuleGroupType;\nfunction convertQuery(query: RuleGroupType | RuleGroupTypeIC): RuleGroupType | RuleGroupTypeIC {\n  return isRuleGroupTypeIC(query) ? convertFromIC(query) : convertToIC(query);\n}\n\nexport { convertQuery };\n"],"mappings":";;AAaA,MAAM,mBAAmB;CAAC;CAAM;CAAO;CAAM;AAE7C,MAAM,gBAAgB,GAAY,MAAc,GAAG,EAAE,KAAK;AAE1D,MAAM,gDACJ,IACA,sBAA8B,MACV;CACpB,MAAM,iBAAiB,iBAAiB;AAGxC,KAAI,CAAC,GAAG,MAAM,SAAS,eAAsB,CAG3C,QAAO,sBAAsB,iBAAiB,SAAS,IACnD,6CAA6C,IAAI,sBAAsB,EAAE,GACzE;CAGN,MAAM,WAAW,CAAC,GAAG,GAAG,MAAM;CAC9B,IAAI,SAAS;AAGb,QAAO,SAAS,SAAS,SAAS,GAAG;AACnC,MAAI,aAAa,SAAS,SAAS,IAAI,eAAe,EAAE;AACtD,aAAU;AACV;;EAGF,IAAI,0BAA0B;AAC9B,OAAK,IAAI,IAAI,SAAS,GAAG,IAAI,SAAS,QAAQ,IAC5C,KAAI,OAAO,SAAS,OAAO,YAAY,GAAG,SAAS,GAAG,KAAK,gBAAgB;AACzE,6BAA0B;AAC1B;;AAIJ,MAAI,4BAA4B,IAAI;AAElC,YAAS,OACP,QACA,SAAS,QACT,6CAEE,EAAE,OAAO,SAAS,MAAM,OAAO,EAAS,EACxC,sBAAsB,EACvB,CACF;AACD;QAGA,UAAS,OACP,QACA,0BAA0B,QAC1B,6CAEE,EAAE,OAAO,SAAS,MAAM,QAAQ,wBAAwB,EAAS,EACjE,sBAAsB,EACvB,CACF;;AAIL,QAAO;EAAE,GAAG;EAAI,OAAO;EAAU;;;;;;;;;;AAWnC,MAAa,iBAA8C,OAAgC;AACzF,KAAI,gBAAgB,GAAG,CACrB,QAAO;CAET,MAAM,cAAc,6CAA6C,GAAG;CACpE,MAAM,QAAwB,EAAE;CAChC,IAAI,aAAa;AACjB,MAAK,MAAM,CAAC,KAAK,MAAM,YAAY,MAAM,SAAS,CAChD,KAAI,OAAO,MAAM;MACX,QAAQ,EAAG,cAAa;OAE5B,OAAM,KAAK,YAAY,EAAE,GAAG,cAAc,EAAE,GAAG,EAAE;AAGrD,QAAO;EAAE,GAAG;EAAa;EAAY;EAAO;;;;;;;;;;AAW9C,MAAa,eAA4C,OAAkC;AACzF,KAAI,kBAAkB,GAAG,CACvB,QAAO;CAET,MAAM,EAAE,YAAY,GAAG,2BAA2B;CAClD,MAAM,QAAiD,EAAE;CACzD,MAAM,EAAE,WAAW,GAAG;AACtB,MAAK,IAAI,MAAM,GAAG,MAAM,QAAQ,OAAO;EACrC,MAAM,IAAI,GAAG,MAAM;AACnB,MAAI,YAAY,EAAE,CAChB,OAAM,KAAK,YAAY,EAAE,CAAC;MAE1B,OAAM,KAAK,EAAE;AAEf,MAAI,cAAc,MAAM,SAAS,EAC/B,OAAM,KAAK,WAAW;;AAG1B,QAAO;EAAE,GAAG;EAAwB;EAAO"}
+{"version":3,"file":"convertQuery-BeJJH9BI.mjs","names":[],"sources":["../src/utils/convertQuery.ts"],"sourcesContent":["import type {\n  RuleGroupArray,\n  RuleGroupICArray,\n  RuleGroupType,\n  RuleGroupTypeAny,\n  RuleGroupTypeIC,\n  RuleType,\n  ToRuleGroupType,\n  ToRuleGroupTypeIC,\n} from '../types';\nimport { isRuleGroup, isRuleGroupType, isRuleGroupTypeIC } from './isRuleGroup';\nimport { lc } from './misc';\n\nconst combinatorLevels = ['or', 'xor', 'and'] as const;\n\nconst isSameString = (a: unknown, b: string) => lc(a) === b;\n\nconst generateRuleGroupICWithConsistentCombinators = (\n  rg: RuleGroupTypeIC,\n  baseCombinatorLevel: number = 0\n): RuleGroupTypeIC => {\n  const baseCombinator = combinatorLevels[baseCombinatorLevel];\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  if (!rg.rules.includes(baseCombinator as any)) {\n    // No instances of this combinator, so group based on the next\n    // combinator level if at least two levels remain\n    return baseCombinatorLevel < combinatorLevels.length - 2\n      ? generateRuleGroupICWithConsistentCombinators(rg, baseCombinatorLevel + 1)\n      : rg;\n  }\n\n  const newRules = [...rg.rules] as RuleGroupICArray;\n  let cursor = 0;\n\n  // Group all chains of combinators in the rule array that are not the base combinator\n  while (cursor < newRules.length - 2) {\n    if (isSameString(newRules[cursor + 1], baseCombinator)) {\n      cursor += 2;\n      continue;\n    }\n\n    let nextBaseCombinatorIndex = -1;\n    for (let i = cursor + 2; i < newRules.length; i++) {\n      if (typeof newRules[i] === 'string' && lc(newRules[i]) === baseCombinator) {\n        nextBaseCombinatorIndex = i;\n        break;\n      }\n    }\n\n    if (nextBaseCombinatorIndex === -1) {\n      // No more instances of this combinator, so group all remaining rules and exit the loop\n      newRules.splice(\n        cursor,\n        newRules.length,\n        generateRuleGroupICWithConsistentCombinators(\n          // oxlint-disable-next-line typescript/no-explicit-any\n          { rules: newRules.slice(cursor) as any },\n          baseCombinatorLevel + 1\n        )\n      );\n      break;\n    } else {\n      // Group all rules between the current cursor and the next instance of the base combinator\n      newRules.splice(\n        cursor,\n        nextBaseCombinatorIndex - cursor,\n        generateRuleGroupICWithConsistentCombinators(\n          // oxlint-disable-next-line typescript/no-explicit-any\n          { rules: newRules.slice(cursor, nextBaseCombinatorIndex) as any },\n          baseCombinatorLevel + 1\n        )\n      );\n    }\n  }\n\n  return { ...rg, rules: newRules };\n};\n\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}.\n *\n * This function is idempotent: {@link RuleGroupType} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertFromIC = <RG extends RuleGroupTypeAny>(rg: RG): ToRuleGroupType<RG> => {\n  if (isRuleGroupType(rg)) {\n    return rg as ToRuleGroupType<RG>;\n  }\n  const processedRG = generateRuleGroupICWithConsistentCombinators(rg);\n  const rules: RuleGroupArray = [];\n  let combinator = 'and';\n  for (const [idx, r] of processedRG.rules.entries()) {\n    if (typeof r === 'string') {\n      if (idx === 1) combinator = r;\n    } else {\n      rules.push(isRuleGroup(r) ? convertFromIC(r) : r);\n    }\n  }\n  return { ...processedRG, combinator, rules } as ToRuleGroupType<RG>;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}.\n *\n * This function is idempotent: {@link RuleGroupTypeIC} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertToIC = <RG extends RuleGroupTypeAny>(rg: RG): ToRuleGroupTypeIC<RG> => {\n  if (isRuleGroupTypeIC(rg)) {\n    return rg as ToRuleGroupTypeIC<RG>;\n  }\n  const { combinator, ...queryWithoutCombinator } = rg;\n  const rules: (RuleGroupTypeIC | RuleType | string)[] = [];\n  const { length } = rg.rules;\n  for (let idx = 0; idx < length; idx++) {\n    const r = rg.rules[idx];\n    if (isRuleGroup(r)) {\n      rules.push(convertToIC(r));\n    } else {\n      rules.push(r);\n    }\n    if (combinator && idx < length - 1) {\n      rules.push(combinator);\n    }\n  }\n  return { ...queryWithoutCombinator, rules } as ToRuleGroupTypeIC<RG>;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}. For a more explicit\n * operation, use {@link convertToIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupType): RuleGroupTypeIC;\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}. For a more explicit\n * operation, use {@link convertFromIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupTypeIC): RuleGroupType;\nfunction convertQuery(query: RuleGroupType | RuleGroupTypeIC): RuleGroupType | RuleGroupTypeIC {\n  return isRuleGroupTypeIC(query) ? convertFromIC(query) : convertToIC(query);\n}\n\nexport { convertQuery };\n"],"mappings":";;AAaA,MAAM,mBAAmB;CAAC;CAAM;CAAO;AAAK;AAE5C,MAAM,gBAAgB,GAAY,MAAc,GAAG,CAAC,MAAM;AAE1D,MAAM,gDACJ,IACA,sBAA8B,MACV;CACpB,MAAM,iBAAiB,iBAAiB;CAGxC,IAAI,CAAC,GAAG,MAAM,SAAS,cAAqB,GAG1C,OAAO,sBAAsB,iBAAiB,SAAS,IACnD,6CAA6C,IAAI,sBAAsB,CAAC,IACxE;CAGN,MAAM,WAAW,CAAC,GAAG,GAAG,KAAK;CAC7B,IAAI,SAAS;CAGb,OAAO,SAAS,SAAS,SAAS,GAAG;EACnC,IAAI,aAAa,SAAS,SAAS,IAAI,cAAc,GAAG;GACtD,UAAU;GACV;EACF;EAEA,IAAI,0BAA0B;EAC9B,KAAK,IAAI,IAAI,SAAS,GAAG,IAAI,SAAS,QAAQ,KAC5C,IAAI,OAAO,SAAS,OAAO,YAAY,GAAG,SAAS,EAAE,MAAM,gBAAgB;GACzE,0BAA0B;GAC1B;EACF;EAGF,IAAI,4BAA4B,IAAI;GAElC,SAAS,OACP,QACA,SAAS,QACT,6CAEE,EAAE,OAAO,SAAS,MAAM,MAAM,EAAS,GACvC,sBAAsB,CACxB,CACF;GACA;EACF,OAEE,SAAS,OACP,QACA,0BAA0B,QAC1B,6CAEE,EAAE,OAAO,SAAS,MAAM,QAAQ,uBAAuB,EAAS,GAChE,sBAAsB,CACxB,CACF;CAEJ;CAEA,OAAO;EAAE,GAAG;EAAI,OAAO;CAAS;AAClC;;;;;;;;;AAUA,MAAa,iBAA8C,OAAgC;CACzF,IAAI,gBAAgB,EAAE,GACpB,OAAO;CAET,MAAM,cAAc,6CAA6C,EAAE;CACnE,MAAM,QAAwB,CAAC;CAC/B,IAAI,aAAa;CACjB,KAAK,MAAM,CAAC,KAAK,MAAM,YAAY,MAAM,QAAQ,GAC/C,IAAI,OAAO,MAAM;MACX,QAAQ,GAAG,aAAa;CAAA,OAE5B,MAAM,KAAK,YAAY,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC;CAGpD,OAAO;EAAE,GAAG;EAAa;EAAY;CAAM;AAC7C;;;;;;;;;AAUA,MAAa,eAA4C,OAAkC;CACzF,IAAI,kBAAkB,EAAE,GACtB,OAAO;CAET,MAAM,EAAE,YAAY,GAAG,2BAA2B;CAClD,MAAM,QAAiD,CAAC;CACxD,MAAM,EAAE,WAAW,GAAG;CACtB,KAAK,IAAI,MAAM,GAAG,MAAM,QAAQ,OAAO;EACrC,MAAM,IAAI,GAAG,MAAM;EACnB,IAAI,YAAY,CAAC,GACf,MAAM,KAAK,YAAY,CAAC,CAAC;OAEzB,MAAM,KAAK,CAAC;EAEd,IAAI,cAAc,MAAM,SAAS,GAC/B,MAAM,KAAK,UAAU;CAEzB;CACA,OAAO;EAAE,GAAG;EAAwB;CAAM;AAC5C"}

package/dist/convertQuery-Lx2HQa0m.js.map

@@ -1 +1 @@
-{"version":3,"file":"convertQuery-Lx2HQa0m.js","names":["lc","isRuleGroupType","isRuleGroup","isRuleGroupTypeIC"],"sources":["../src/utils/convertQuery.ts"],"sourcesContent":["import type {\n  RuleGroupArray,\n  RuleGroupICArray,\n  RuleGroupType,\n  RuleGroupTypeAny,\n  RuleGroupTypeIC,\n  RuleType,\n  ToRuleGroupType,\n  ToRuleGroupTypeIC,\n} from '../types';\nimport { isRuleGroup, isRuleGroupType, isRuleGroupTypeIC } from './isRuleGroup';\nimport { lc } from './misc';\n\nconst combinatorLevels = ['or', 'xor', 'and'] as const;\n\nconst isSameString = (a: unknown, b: string) => lc(a) === b;\n\nconst generateRuleGroupICWithConsistentCombinators = (\n  rg: RuleGroupTypeIC,\n  baseCombinatorLevel: number = 0\n): RuleGroupTypeIC => {\n  const baseCombinator = combinatorLevels[baseCombinatorLevel];\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  if (!rg.rules.includes(baseCombinator as any)) {\n    // No instances of this combinator, so group based on the next\n    // combinator level if at least two levels remain\n    return baseCombinatorLevel < combinatorLevels.length - 2\n      ? generateRuleGroupICWithConsistentCombinators(rg, baseCombinatorLevel + 1)\n      : rg;\n  }\n\n  const newRules = [...rg.rules] as RuleGroupICArray;\n  let cursor = 0;\n\n  // Group all chains of combinators in the rule array that are not the base combinator\n  while (cursor < newRules.length - 2) {\n    if (isSameString(newRules[cursor + 1], baseCombinator)) {\n      cursor += 2;\n      continue;\n    }\n\n    let nextBaseCombinatorIndex = -1;\n    for (let i = cursor + 2; i < newRules.length; i++) {\n      if (typeof newRules[i] === 'string' && lc(newRules[i]) === baseCombinator) {\n        nextBaseCombinatorIndex = i;\n        break;\n      }\n    }\n\n    if (nextBaseCombinatorIndex === -1) {\n      // No more instances of this combinator, so group all remaining rules and exit the loop\n      newRules.splice(\n        cursor,\n        newRules.length,\n        generateRuleGroupICWithConsistentCombinators(\n          // oxlint-disable-next-line typescript/no-explicit-any\n          { rules: newRules.slice(cursor) as any },\n          baseCombinatorLevel + 1\n        )\n      );\n      break;\n    } else {\n      // Group all rules between the current cursor and the next instance of the base combinator\n      newRules.splice(\n        cursor,\n        nextBaseCombinatorIndex - cursor,\n        generateRuleGroupICWithConsistentCombinators(\n          // oxlint-disable-next-line typescript/no-explicit-any\n          { rules: newRules.slice(cursor, nextBaseCombinatorIndex) as any },\n          baseCombinatorLevel + 1\n        )\n      );\n    }\n  }\n\n  return { ...rg, rules: newRules };\n};\n\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}.\n *\n * This function is idempotent: {@link RuleGroupType} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertFromIC = <RG extends RuleGroupTypeAny>(rg: RG): ToRuleGroupType<RG> => {\n  if (isRuleGroupType(rg)) {\n    return rg as ToRuleGroupType<RG>;\n  }\n  const processedRG = generateRuleGroupICWithConsistentCombinators(rg);\n  const rules: RuleGroupArray = [];\n  let combinator = 'and';\n  for (const [idx, r] of processedRG.rules.entries()) {\n    if (typeof r === 'string') {\n      if (idx === 1) combinator = r;\n    } else {\n      rules.push(isRuleGroup(r) ? convertFromIC(r) : r);\n    }\n  }\n  return { ...processedRG, combinator, rules } as ToRuleGroupType<RG>;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}.\n *\n * This function is idempotent: {@link RuleGroupTypeIC} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertToIC = <RG extends RuleGroupTypeAny>(rg: RG): ToRuleGroupTypeIC<RG> => {\n  if (isRuleGroupTypeIC(rg)) {\n    return rg as ToRuleGroupTypeIC<RG>;\n  }\n  const { combinator, ...queryWithoutCombinator } = rg;\n  const rules: (RuleGroupTypeIC | RuleType | string)[] = [];\n  const { length } = rg.rules;\n  for (let idx = 0; idx < length; idx++) {\n    const r = rg.rules[idx];\n    if (isRuleGroup(r)) {\n      rules.push(convertToIC(r));\n    } else {\n      rules.push(r);\n    }\n    if (combinator && idx < length - 1) {\n      rules.push(combinator);\n    }\n  }\n  return { ...queryWithoutCombinator, rules } as ToRuleGroupTypeIC<RG>;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}. For a more explicit\n * operation, use {@link convertToIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupType): RuleGroupTypeIC;\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}. For a more explicit\n * operation, use {@link convertFromIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupTypeIC): RuleGroupType;\nfunction convertQuery(query: RuleGroupType | RuleGroupTypeIC): RuleGroupType | RuleGroupTypeIC {\n  return isRuleGroupTypeIC(query) ? convertFromIC(query) : convertToIC(query);\n}\n\nexport { convertQuery };\n"],"mappings":";;AAaA,MAAM,mBAAmB;CAAC;CAAM;CAAO;CAAM;AAE7C,MAAM,gBAAgB,GAAY,MAAcA,oBAAAA,GAAG,EAAE,KAAK;AAE1D,MAAM,gDACJ,IACA,sBAA8B,MACV;CACpB,MAAM,iBAAiB,iBAAiB;AAGxC,KAAI,CAAC,GAAG,MAAM,SAAS,eAAsB,CAG3C,QAAO,sBAAsB,iBAAiB,SAAS,IACnD,6CAA6C,IAAI,sBAAsB,EAAE,GACzE;CAGN,MAAM,WAAW,CAAC,GAAG,GAAG,MAAM;CAC9B,IAAI,SAAS;AAGb,QAAO,SAAS,SAAS,SAAS,GAAG;AACnC,MAAI,aAAa,SAAS,SAAS,IAAI,eAAe,EAAE;AACtD,aAAU;AACV;;EAGF,IAAI,0BAA0B;AAC9B,OAAK,IAAI,IAAI,SAAS,GAAG,IAAI,SAAS,QAAQ,IAC5C,KAAI,OAAO,SAAS,OAAO,YAAYA,oBAAAA,GAAG,SAAS,GAAG,KAAK,gBAAgB;AACzE,6BAA0B;AAC1B;;AAIJ,MAAI,4BAA4B,IAAI;AAElC,YAAS,OACP,QACA,SAAS,QACT,6CAEE,EAAE,OAAO,SAAS,MAAM,OAAO,EAAS,EACxC,sBAAsB,EACvB,CACF;AACD;QAGA,UAAS,OACP,QACA,0BAA0B,QAC1B,6CAEE,EAAE,OAAO,SAAS,MAAM,QAAQ,wBAAwB,EAAS,EACjE,sBAAsB,EACvB,CACF;;AAIL,QAAO;EAAE,GAAG;EAAI,OAAO;EAAU;;;;;;;;;;AAWnC,MAAa,iBAA8C,OAAgC;AACzF,KAAIC,oBAAAA,gBAAgB,GAAG,CACrB,QAAO;CAET,MAAM,cAAc,6CAA6C,GAAG;CACpE,MAAM,QAAwB,EAAE;CAChC,IAAI,aAAa;AACjB,MAAK,MAAM,CAAC,KAAK,MAAM,YAAY,MAAM,SAAS,CAChD,KAAI,OAAO,MAAM;MACX,QAAQ,EAAG,cAAa;OAE5B,OAAM,KAAKC,oBAAAA,YAAY,EAAE,GAAG,cAAc,EAAE,GAAG,EAAE;AAGrD,QAAO;EAAE,GAAG;EAAa;EAAY;EAAO;;;;;;;;;;AAW9C,MAAa,eAA4C,OAAkC;AACzF,KAAIC,oBAAAA,kBAAkB,GAAG,CACvB,QAAO;CAET,MAAM,EAAE,YAAY,GAAG,2BAA2B;CAClD,MAAM,QAAiD,EAAE;CACzD,MAAM,EAAE,WAAW,GAAG;AACtB,MAAK,IAAI,MAAM,GAAG,MAAM,QAAQ,OAAO;EACrC,MAAM,IAAI,GAAG,MAAM;AACnB,MAAID,oBAAAA,YAAY,EAAE,CAChB,OAAM,KAAK,YAAY,EAAE,CAAC;MAE1B,OAAM,KAAK,EAAE;AAEf,MAAI,cAAc,MAAM,SAAS,EAC/B,OAAM,KAAK,WAAW;;AAG1B,QAAO;EAAE,GAAG;EAAwB;EAAO"}
+{"version":3,"file":"convertQuery-Lx2HQa0m.js","names":["lc","isRuleGroupType","isRuleGroup","isRuleGroupTypeIC"],"sources":["../src/utils/convertQuery.ts"],"sourcesContent":["import type {\n  RuleGroupArray,\n  RuleGroupICArray,\n  RuleGroupType,\n  RuleGroupTypeAny,\n  RuleGroupTypeIC,\n  RuleType,\n  ToRuleGroupType,\n  ToRuleGroupTypeIC,\n} from '../types';\nimport { isRuleGroup, isRuleGroupType, isRuleGroupTypeIC } from './isRuleGroup';\nimport { lc } from './misc';\n\nconst combinatorLevels = ['or', 'xor', 'and'] as const;\n\nconst isSameString = (a: unknown, b: string) => lc(a) === b;\n\nconst generateRuleGroupICWithConsistentCombinators = (\n  rg: RuleGroupTypeIC,\n  baseCombinatorLevel: number = 0\n): RuleGroupTypeIC => {\n  const baseCombinator = combinatorLevels[baseCombinatorLevel];\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  if (!rg.rules.includes(baseCombinator as any)) {\n    // No instances of this combinator, so group based on the next\n    // combinator level if at least two levels remain\n    return baseCombinatorLevel < combinatorLevels.length - 2\n      ? generateRuleGroupICWithConsistentCombinators(rg, baseCombinatorLevel + 1)\n      : rg;\n  }\n\n  const newRules = [...rg.rules] as RuleGroupICArray;\n  let cursor = 0;\n\n  // Group all chains of combinators in the rule array that are not the base combinator\n  while (cursor < newRules.length - 2) {\n    if (isSameString(newRules[cursor + 1], baseCombinator)) {\n      cursor += 2;\n      continue;\n    }\n\n    let nextBaseCombinatorIndex = -1;\n    for (let i = cursor + 2; i < newRules.length; i++) {\n      if (typeof newRules[i] === 'string' && lc(newRules[i]) === baseCombinator) {\n        nextBaseCombinatorIndex = i;\n        break;\n      }\n    }\n\n    if (nextBaseCombinatorIndex === -1) {\n      // No more instances of this combinator, so group all remaining rules and exit the loop\n      newRules.splice(\n        cursor,\n        newRules.length,\n        generateRuleGroupICWithConsistentCombinators(\n          // oxlint-disable-next-line typescript/no-explicit-any\n          { rules: newRules.slice(cursor) as any },\n          baseCombinatorLevel + 1\n        )\n      );\n      break;\n    } else {\n      // Group all rules between the current cursor and the next instance of the base combinator\n      newRules.splice(\n        cursor,\n        nextBaseCombinatorIndex - cursor,\n        generateRuleGroupICWithConsistentCombinators(\n          // oxlint-disable-next-line typescript/no-explicit-any\n          { rules: newRules.slice(cursor, nextBaseCombinatorIndex) as any },\n          baseCombinatorLevel + 1\n        )\n      );\n    }\n  }\n\n  return { ...rg, rules: newRules };\n};\n\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}.\n *\n * This function is idempotent: {@link RuleGroupType} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertFromIC = <RG extends RuleGroupTypeAny>(rg: RG): ToRuleGroupType<RG> => {\n  if (isRuleGroupType(rg)) {\n    return rg as ToRuleGroupType<RG>;\n  }\n  const processedRG = generateRuleGroupICWithConsistentCombinators(rg);\n  const rules: RuleGroupArray = [];\n  let combinator = 'and';\n  for (const [idx, r] of processedRG.rules.entries()) {\n    if (typeof r === 'string') {\n      if (idx === 1) combinator = r;\n    } else {\n      rules.push(isRuleGroup(r) ? convertFromIC(r) : r);\n    }\n  }\n  return { ...processedRG, combinator, rules } as ToRuleGroupType<RG>;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}.\n *\n * This function is idempotent: {@link RuleGroupTypeIC} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertToIC = <RG extends RuleGroupTypeAny>(rg: RG): ToRuleGroupTypeIC<RG> => {\n  if (isRuleGroupTypeIC(rg)) {\n    return rg as ToRuleGroupTypeIC<RG>;\n  }\n  const { combinator, ...queryWithoutCombinator } = rg;\n  const rules: (RuleGroupTypeIC | RuleType | string)[] = [];\n  const { length } = rg.rules;\n  for (let idx = 0; idx < length; idx++) {\n    const r = rg.rules[idx];\n    if (isRuleGroup(r)) {\n      rules.push(convertToIC(r));\n    } else {\n      rules.push(r);\n    }\n    if (combinator && idx < length - 1) {\n      rules.push(combinator);\n    }\n  }\n  return { ...queryWithoutCombinator, rules } as ToRuleGroupTypeIC<RG>;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}. For a more explicit\n * operation, use {@link convertToIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupType): RuleGroupTypeIC;\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}. For a more explicit\n * operation, use {@link convertFromIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupTypeIC): RuleGroupType;\nfunction convertQuery(query: RuleGroupType | RuleGroupTypeIC): RuleGroupType | RuleGroupTypeIC {\n  return isRuleGroupTypeIC(query) ? convertFromIC(query) : convertToIC(query);\n}\n\nexport { convertQuery };\n"],"mappings":";;AAaA,MAAM,mBAAmB;CAAC;CAAM;CAAO;AAAK;AAE5C,MAAM,gBAAgB,GAAY,MAAcA,oBAAAA,GAAG,CAAC,MAAM;AAE1D,MAAM,gDACJ,IACA,sBAA8B,MACV;CACpB,MAAM,iBAAiB,iBAAiB;CAGxC,IAAI,CAAC,GAAG,MAAM,SAAS,cAAqB,GAG1C,OAAO,sBAAsB,iBAAiB,SAAS,IACnD,6CAA6C,IAAI,sBAAsB,CAAC,IACxE;CAGN,MAAM,WAAW,CAAC,GAAG,GAAG,KAAK;CAC7B,IAAI,SAAS;CAGb,OAAO,SAAS,SAAS,SAAS,GAAG;EACnC,IAAI,aAAa,SAAS,SAAS,IAAI,cAAc,GAAG;GACtD,UAAU;GACV;EACF;EAEA,IAAI,0BAA0B;EAC9B,KAAK,IAAI,IAAI,SAAS,GAAG,IAAI,SAAS,QAAQ,KAC5C,IAAI,OAAO,SAAS,OAAO,YAAYA,oBAAAA,GAAG,SAAS,EAAE,MAAM,gBAAgB;GACzE,0BAA0B;GAC1B;EACF;EAGF,IAAI,4BAA4B,IAAI;GAElC,SAAS,OACP,QACA,SAAS,QACT,6CAEE,EAAE,OAAO,SAAS,MAAM,MAAM,EAAS,GACvC,sBAAsB,CACxB,CACF;GACA;EACF,OAEE,SAAS,OACP,QACA,0BAA0B,QAC1B,6CAEE,EAAE,OAAO,SAAS,MAAM,QAAQ,uBAAuB,EAAS,GAChE,sBAAsB,CACxB,CACF;CAEJ;CAEA,OAAO;EAAE,GAAG;EAAI,OAAO;CAAS;AAClC;;;;;;;;;AAUA,MAAa,iBAA8C,OAAgC;CACzF,IAAIC,oBAAAA,gBAAgB,EAAE,GACpB,OAAO;CAET,MAAM,cAAc,6CAA6C,EAAE;CACnE,MAAM,QAAwB,CAAC;CAC/B,IAAI,aAAa;CACjB,KAAK,MAAM,CAAC,KAAK,MAAM,YAAY,MAAM,QAAQ,GAC/C,IAAI,OAAO,MAAM;MACX,QAAQ,GAAG,aAAa;CAAA,OAE5B,MAAM,KAAKC,oBAAAA,YAAY,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC;CAGpD,OAAO;EAAE,GAAG;EAAa;EAAY;CAAM;AAC7C;;;;;;;;;AAUA,MAAa,eAA4C,OAAkC;CACzF,IAAIC,oBAAAA,kBAAkB,EAAE,GACtB,OAAO;CAET,MAAM,EAAE,YAAY,GAAG,2BAA2B;CAClD,MAAM,QAAiD,CAAC;CACxD,MAAM,EAAE,WAAW,GAAG;CACtB,KAAK,IAAI,MAAM,GAAG,MAAM,QAAQ,OAAO;EACrC,MAAM,IAAI,GAAG,MAAM;EACnB,IAAID,oBAAAA,YAAY,CAAC,GACf,MAAM,KAAK,YAAY,CAAC,CAAC;OAEzB,MAAM,KAAK,CAAC;EAEd,IAAI,cAAc,MAAM,SAAS,GAC/B,MAAM,KAAK,UAAU;CAEzB;CACA,OAAO;EAAE,GAAG;EAAwB;CAAM;AAC5C"}

package/dist/formatQuery.d.mts

@@ -1,6 +1,7 @@
-import { A as SetRequired, O as RuleType, S as RuleGroupTypeAny, _ as ValueProcessorLegacy, a as ExportOperatorMap, c as NLTranslationKey, d as ParameterizedSQL, f as RQBJsonLogic, g as ValueProcessorByRule, h as SQLPreset, i as ExportObjectFormats, l as NLTranslations, m as RuleProcessor, n as DiagnosticsResult, o as FormatQueryOptions, p as RuleGroupProcessor, r as ExportFormat, s as GroupVariantCondition, t as ConstituentWordOrder, u as ParameterizedNamedSQL, v as ValueProcessorOptions } from "./index-D-Iej37L.mjs";
+import { A as SetRequired, O as RuleType, S as RuleGroupTypeAny, _ as ValueProcessorLegacy, a as ExportOperatorMap, c as NLTranslationKey, d as ParameterizedSQL, f as RQBJsonLogic, g as ValueProcessorByRule, h as SQLPreset, i as ExportObjectFormats, l as NLTranslations, m as RuleProcessor, n as DiagnosticsResult, o as FormatQueryOptions, p as RuleGroupProcessor, r as ExportFormat, s as GroupVariantCondition, t as ConstituentWordOrder, u as ParameterizedNamedSQL, v as ValueProcessorOptions } from "./index-CR-tk4Ci.mjs";
 import { Column, Operators, SQL, Table } from "drizzle-orm";
 import { WhereOptions } from "sequelize";
+import { eq } from "@tanstack/db";
 
 //#region src/utils/formatQuery/defaultRuleProcessorCEL.d.ts
 /**
@@ -213,6 +214,23 @@ declare const defaultRuleGroupProcessorSpEL: RuleGroupProcessor<string>;
 */
 declare const defaultRuleGroupProcessorSQL: RuleGroupProcessor<string>;
 //#endregion
+//#region src/utils/formatQuery/tanStackDbTypes.d.ts
+type TanStackDbWhereCallbackReturnType = ReturnType<typeof eq>;
+type TanStackDbWhereCallback = (refs: Record<string, unknown>) => TanStackDbWhereCallbackReturnType;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorTanStackDB.d.ts
+/**
+* Default rule group processor used by {@link formatQuery} for the "tanstack_db" format.
+* Returns a `WhereCallback` suitable for TanStack DB's `.where()` method.
+*
+* @example
+* const where = formatQuery(query, { format: 'tanstack_db', context: { tanstackDb: tsdb } });
+* const results = useLiveQuery(q => q.from({ todo: todosCollection }).where(where));
+*
+* @group Export
+*/
+declare const defaultRuleGroupProcessorTanStackDB: RuleGroupProcessor<TanStackDbWhereCallback>;
+//#endregion
 //#region src/utils/formatQuery/defaultRuleGroupProcessorDiagnostics.d.ts
 /**
 * Rule group processor used by {@link formatQuery} for "diagnostics" format.
@@ -338,6 +356,11 @@ declare const defaultRuleProcessorPrisma: RuleProcessor;
 declare const defaultRuleProcessorSequelize: RuleProcessor;
 //#endregion
 //#region src/utils/formatQuery/defaultRuleProcessorSPARQL.d.ts
+/** Auto-prefix a SPARQL variable name with `?` unless it's already prefixed, a URI, or a prefixed name.
+*
+* @group Export
+*/
+declare const sparqlVar: (name: string) => string;
 /**
 * Default rule processor used by {@link formatQuery} for "sparql" format.
 *
@@ -359,6 +382,14 @@ declare const defaultOperatorProcessorSQL: RuleProcessor;
 */
 declare const defaultRuleProcessorSQL: RuleProcessor;
 //#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorTanStackDB.d.ts
+/**
+* Default rule processor used by {@link formatQuery} for the "tanstack_db" format.
+*
+* @group Export
+*/
+declare const defaultRuleProcessorTanStackDB: RuleProcessor;
+//#endregion
 //#region src/utils/formatQuery/defaultValueProcessorNL.d.ts
 /**
 * Default value processor used by {@link formatQuery} for "natural_language" format.
@@ -472,7 +503,15 @@ declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "drizzle" | (
   format: "drizzle";
 })): ReturnType<typeof defaultRuleGroupProcessorDrizzle>;
 /**
-* Generates a Sequelize query object from an RQB query object. The object can
+* Generates a TanStack DB WhereCallback from an RQB query object. The callback can
+* be passed directly to TanStack DB's `.where()` method.
+*
+* @group Export
+*/
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "tanstack_db" | (FormatQueryOptions & {
+  format: "tanstack_db";
+})): ReturnType<typeof defaultRuleGroupProcessorTanStackDB>;
+/**
 * be assigned to the `where` property in the Sequelize query functions.
 *
 * @group Export
@@ -762,5 +801,5 @@ declare const defaultValueProcessorMongoDBByRule: RuleProcessor;
 */
 declare const defaultValueProcessorSpELByRule: RuleProcessor;
 //#endregion
-export { bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, cypherCombinatorMap, defaultCELValueProcessor, defaultExportOperatorMap, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultSpELValueProcessor, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, formatQuery, formatQueryOptionPresets, getNLTranslataion, getQuoteFieldNamesWithArray, getQuotedFieldName, isValidValue, isValueProcessorLegacy, jsonLogicAdditionalOperators, mapSQLOperator, mongoDbFallback, mongoOperators, normalizeConstituentWordOrder, numerifyValues, prismaFallback, prismaOperators, processMatchMode, shouldRenderAsNumber, sqlDialectPresets };
+export { bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, cypherCombinatorMap, defaultCELValueProcessor, defaultExportOperatorMap, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleGroupProcessorTanStackDB, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultRuleProcessorTanStackDB, defaultSpELValueProcessor, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, formatQuery, formatQueryOptionPresets, getNLTranslataion, getQuoteFieldNamesWithArray, getQuotedFieldName, isValidValue, isValueProcessorLegacy, jsonLogicAdditionalOperators, mapSQLOperator, mongoDbFallback, mongoOperators, normalizeConstituentWordOrder, numerifyValues, prismaFallback, prismaOperators, processMatchMode, shouldRenderAsNumber, sparqlVar, sqlDialectPresets };
 //# sourceMappingURL=formatQuery.d.mts.map

package/dist/formatQuery.d.ts

@@ -1,6 +1,7 @@
-import { A as SetRequired, O as RuleType, S as RuleGroupTypeAny, _ as ValueProcessorLegacy, a as ExportOperatorMap, c as NLTranslationKey, d as ParameterizedSQL, f as RQBJsonLogic, g as ValueProcessorByRule, h as SQLPreset, i as ExportObjectFormats, l as NLTranslations, m as RuleProcessor, n as DiagnosticsResult, o as FormatQueryOptions, p as RuleGroupProcessor, r as ExportFormat, s as GroupVariantCondition, t as ConstituentWordOrder, u as ParameterizedNamedSQL, v as ValueProcessorOptions } from "./index-Cjapnb-H.js";
+import { A as SetRequired, O as RuleType, S as RuleGroupTypeAny, _ as ValueProcessorLegacy, a as ExportOperatorMap, c as NLTranslationKey, d as ParameterizedSQL, f as RQBJsonLogic, g as ValueProcessorByRule, h as SQLPreset, i as ExportObjectFormats, l as NLTranslations, m as RuleProcessor, n as DiagnosticsResult, o as FormatQueryOptions, p as RuleGroupProcessor, r as ExportFormat, s as GroupVariantCondition, t as ConstituentWordOrder, u as ParameterizedNamedSQL, v as ValueProcessorOptions } from "./index-NSVgGj45.js";
 import { Column, Operators, SQL, Table } from "drizzle-orm";
 import { WhereOptions } from "sequelize";
+import { eq } from "@tanstack/db";
 
 //#region src/utils/formatQuery/defaultRuleProcessorCEL.d.ts
 /**
@@ -213,6 +214,23 @@ declare const defaultRuleGroupProcessorSpEL: RuleGroupProcessor<string>;
 */
 declare const defaultRuleGroupProcessorSQL: RuleGroupProcessor<string>;
 //#endregion
+//#region src/utils/formatQuery/tanStackDbTypes.d.ts
+type TanStackDbWhereCallbackReturnType = ReturnType<typeof eq>;
+type TanStackDbWhereCallback = (refs: Record<string, unknown>) => TanStackDbWhereCallbackReturnType;
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorTanStackDB.d.ts
+/**
+* Default rule group processor used by {@link formatQuery} for the "tanstack_db" format.
+* Returns a `WhereCallback` suitable for TanStack DB's `.where()` method.
+*
+* @example
+* const where = formatQuery(query, { format: 'tanstack_db', context: { tanstackDb: tsdb } });
+* const results = useLiveQuery(q => q.from({ todo: todosCollection }).where(where));
+*
+* @group Export
+*/
+declare const defaultRuleGroupProcessorTanStackDB: RuleGroupProcessor<TanStackDbWhereCallback>;
+//#endregion
 //#region src/utils/formatQuery/defaultRuleGroupProcessorDiagnostics.d.ts
 /**
 * Rule group processor used by {@link formatQuery} for "diagnostics" format.
@@ -338,6 +356,11 @@ declare const defaultRuleProcessorPrisma: RuleProcessor;
 declare const defaultRuleProcessorSequelize: RuleProcessor;
 //#endregion
 //#region src/utils/formatQuery/defaultRuleProcessorSPARQL.d.ts
+/** Auto-prefix a SPARQL variable name with `?` unless it's already prefixed, a URI, or a prefixed name.
+*
+* @group Export
+*/
+declare const sparqlVar: (name: string) => string;
 /**
 * Default rule processor used by {@link formatQuery} for "sparql" format.
 *
@@ -359,6 +382,14 @@ declare const defaultOperatorProcessorSQL: RuleProcessor;
 */
 declare const defaultRuleProcessorSQL: RuleProcessor;
 //#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorTanStackDB.d.ts
+/**
+* Default rule processor used by {@link formatQuery} for the "tanstack_db" format.
+*
+* @group Export
+*/
+declare const defaultRuleProcessorTanStackDB: RuleProcessor;
+//#endregion
 //#region src/utils/formatQuery/defaultValueProcessorNL.d.ts
 /**
 * Default value processor used by {@link formatQuery} for "natural_language" format.
@@ -472,7 +503,15 @@ declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "drizzle" | (
   format: "drizzle";
 })): ReturnType<typeof defaultRuleGroupProcessorDrizzle>;
 /**
-* Generates a Sequelize query object from an RQB query object. The object can
+* Generates a TanStack DB WhereCallback from an RQB query object. The callback can
+* be passed directly to TanStack DB's `.where()` method.
+*
+* @group Export
+*/
+declare function formatQuery(ruleGroup: RuleGroupTypeAny, options: "tanstack_db" | (FormatQueryOptions & {
+  format: "tanstack_db";
+})): ReturnType<typeof defaultRuleGroupProcessorTanStackDB>;
+/**
 * be assigned to the `where` property in the Sequelize query functions.
 *
 * @group Export
@@ -762,5 +801,5 @@ declare const defaultValueProcessorMongoDBByRule: RuleProcessor;
 */
 declare const defaultValueProcessorSpELByRule: RuleProcessor;
 //#endregion
-export { bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, cypherCombinatorMap, defaultCELValueProcessor, defaultExportOperatorMap, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultSpELValueProcessor, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, formatQuery, formatQueryOptionPresets, getNLTranslataion, getQuoteFieldNamesWithArray, getQuotedFieldName, isValidValue, isValueProcessorLegacy, jsonLogicAdditionalOperators, mapSQLOperator, mongoDbFallback, mongoOperators, normalizeConstituentWordOrder, numerifyValues, prismaFallback, prismaOperators, processMatchMode, shouldRenderAsNumber, sqlDialectPresets };
+export { bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, cypherCombinatorMap, defaultCELValueProcessor, defaultExportOperatorMap, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleGroupProcessorTanStackDB, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultRuleProcessorTanStackDB, defaultSpELValueProcessor, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, formatQuery, formatQueryOptionPresets, getNLTranslataion, getQuoteFieldNamesWithArray, getQuotedFieldName, isValidValue, isValueProcessorLegacy, jsonLogicAdditionalOperators, mapSQLOperator, mongoDbFallback, mongoOperators, normalizeConstituentWordOrder, numerifyValues, prismaFallback, prismaOperators, processMatchMode, shouldRenderAsNumber, sparqlVar, sqlDialectPresets };
 //# sourceMappingURL=formatQuery.d.ts.map

package/dist/formatQuery.js

@@ -524,7 +524,7 @@ const defaultValueProcessorByRule = ({ operator, value, valueSource }, { escapeQ
 				valsOneAndTwoOnly[0] = secondNum;
 				valsOneAndTwoOnly[1] = firstNum;
 			}
-			return (valueIsField ? valsOneAndTwoOnly.map((v) => wrapFieldName(v)) : valsOneAndTwoOnly.every((v) => require_utils.shouldRenderAsNumber(v, parseNumbers)) ? valsOneAndTwoOnly.map((v) => require_utils.parseNumber(v, { parseNumbers: "strict" })) : valsOneAndTwoOnly.map((v) => wrapAndEscape(v))).join(` ${translations?.and ?? "and"} `);
+			return (valueIsField ? valsOneAndTwoOnly.map((v) => wrapFieldName(v)) : valsOneAndTwoOnly.every((v) => require_utils.shouldRenderAsNumber(v, parseNumbers)) ? valsOneAndTwoOnly.map((v) => require_utils.parseNumber(v, { parseNumbers: "strict" })) : valsOneAndTwoOnly.map((v) => wrapAndEscape(v))).join(` ${translations?.betweenAnd ?? translations?.and ?? "and"} `);
 		}
 		case "contains":
 		case "doesnotcontain": return valueIsField ? concat(quoteValue("%"), wrapFieldName(value), quoteValue("%")) : quoteValue(`%${escapeValue(value)}%`);
@@ -619,6 +619,10 @@ const defaultRuleProcessorDrizzle = (rule, _options) => {
 	const operatorLC = require_objectUtils.lc(operator);
 	const valueIsField = valueSource === "field";
 	const asFieldOrValue = (v) => valueIsField ? columns[v] : v;
+	const maybeParseNumber = (v) => {
+		if (valueIsField || !parseNumbers) return asFieldOrValue(v);
+		return require_utils.shouldRenderAsNumber(v, true) ? require_utils.parseNumber(v, { parseNumbers: true }) : v;
+	};
 	if (!column) return void 0;
 	const matchEval = require_utils.processMatchMode(rule);
 	if (matchEval === false) return;
@@ -649,12 +653,12 @@ const defaultRuleProcessorDrizzle = (rule, _options) => {
 		}
 	}
 	switch (operatorLC) {
-		case "=": return eq(column, asFieldOrValue(value));
-		case "!=": return ne(column, asFieldOrValue(value));
-		case ">": return gt(column, asFieldOrValue(value));
-		case "<": return lt(column, asFieldOrValue(value));
-		case ">=": return gte(column, asFieldOrValue(value));
-		case "<=": return lte(column, asFieldOrValue(value));
+		case "=": return eq(column, maybeParseNumber(value));
+		case "!=": return ne(column, maybeParseNumber(value));
+		case ">": return gt(column, maybeParseNumber(value));
+		case "<": return lt(column, maybeParseNumber(value));
+		case ">=": return gte(column, maybeParseNumber(value));
+		case "<=": return lte(column, maybeParseNumber(value));
 		case "beginswith":
 		case "doesnotbeginwith": return (operatorLC === "doesnotbeginwith" ? notLike : like)(column, valueIsField ? sql`${asFieldOrValue(value)} || '%'` : `${value}%`);
 		case "contains":
@@ -665,7 +669,7 @@ const defaultRuleProcessorDrizzle = (rule, _options) => {
 		case "notnull": return isNotNull(column);
 		case "in":
 		case "notin": {
-			const valueAsArray = require_utils.toArray(value).map((v) => asFieldOrValue(v));
+			const valueAsArray = require_utils.toArray(value).map((v) => maybeParseNumber(v));
 			return operatorLC === "notin" ? notInArray(column, valueAsArray) : inArray(column, valueAsArray);
 		}
 		case "between":
@@ -999,7 +1003,7 @@ const defaultRuleGroupProcessorNL = (ruleGroup, options) => {
 		let firstRule = true;
 		for (const rule of rg2.rules) {
 			if (typeof rule === "string") {
-				precedingCombinator = `, ${translations[rule] ?? rule} `;
+				precedingCombinator = `${translations.ruleSeparator ?? ", "}${translations[rule] ?? rule} `;
 				continue;
 			}
 			if (require_objectUtils.isRuleGroup(rule)) {
@@ -1041,7 +1045,8 @@ const defaultRuleGroupProcessorNL = (ruleGroup, options) => {
 		const [prefixTL, suffixTL] = ["groupPrefix", "groupSuffix"].map((key) => rg2.not ? isXOR ? require_utils.getNLTranslataion(key, translations, ["not", "xor"]) : require_utils.getNLTranslataion(key, translations, ["not"]) : isXOR ? require_utils.getNLTranslataion(key, translations, ["xor"]) : require_utils.getNLTranslataion(key, translations));
 		const prefix = mustWrap ? `${prefixTL} (`.trim() : "";
 		const suffix = mustWrap ? `) ${suffixTL}`.trim() : "";
-		return `${prefix}${processedRules.join(require_objectUtils.isRuleGroupType(rg2) ? `, ${translations[combinator] ?? combinator} ` : "")}${suffix}`;
+		const sep = translations.ruleSeparator ?? ", ";
+		return `${prefix}${processedRules.join(require_objectUtils.isRuleGroupType(rg2) ? `${sep}${translations[combinator] ?? combinator} ` : "")}${suffix}`;
 	};
 	return processRuleGroup(ruleGroup, true);
 };
@@ -1329,6 +1334,142 @@ const defaultRuleGroupProcessorSQL = (ruleGroup, options) => {
 	return processRuleGroup(ruleGroup, true);
 };
 //#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorTanStackDB.ts
+/**
+* Default rule processor used by {@link formatQuery} for the "tanstack_db" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorTanStackDB = (rule, _options) => {
+	const { parseNumbers, preserveValueOrder, context = {} } = _options ?? (	/* v8 ignore start -- @preserve */ {});
+	const ops = context.tanStackDbOperators;
+	const refs = context._tanstackDbRefs;
+	const primaryRef = context._tanstackDbPrimaryRef;
+	if (!ops || !refs || !primaryRef) return void 0;
+	const { and, eq, gt, gte, inArray, isNull, like, lt, lte, not } = ops;
+	const resolveField = (fieldName) => {
+		const dotIdx = fieldName.indexOf(".");
+		if (dotIdx > 0) {
+			const prefix = fieldName.slice(0, dotIdx);
+			const rest = fieldName.slice(dotIdx + 1);
+			if (refs[prefix]) return refs[prefix][rest];
+		}
+		return refs[primaryRef][fieldName];
+	};
+	const { field, operator, value, valueSource } = rule;
+	const column = resolveField(field);
+	const operatorLC = require_objectUtils.lc(operator);
+	const valueIsField = valueSource === "field";
+	const asFieldOrValue = (v) => valueIsField ? resolveField(v) : v;
+	const maybeParseNumber = (v) => {
+		if (valueIsField || !parseNumbers) return asFieldOrValue(v);
+		return require_utils.shouldRenderAsNumber(v, true) ? require_utils.parseNumber(v, { parseNumbers: true }) : v;
+	};
+	switch (operatorLC) {
+		case "=": return eq(column, maybeParseNumber(value));
+		case "!=": return not(eq(column, maybeParseNumber(value)));
+		case ">": return gt(column, maybeParseNumber(value));
+		case "<": return lt(column, maybeParseNumber(value));
+		case ">=": return gte(column, maybeParseNumber(value));
+		case "<=": return lte(column, maybeParseNumber(value));
+		case "beginswith":
+		case "doesnotbeginwith": {
+			const expr = like(column, valueIsField ? void 0 : `${value}%`);
+			return operatorLC === "doesnotbeginwith" ? not(expr) : expr;
+		}
+		case "contains":
+		case "doesnotcontain": {
+			const expr = like(column, valueIsField ? void 0 : `%${value}%`);
+			return operatorLC === "doesnotcontain" ? not(expr) : expr;
+		}
+		case "endswith":
+		case "doesnotendwith": {
+			const expr = like(column, valueIsField ? void 0 : `%${value}`);
+			return operatorLC === "doesnotendwith" ? not(expr) : expr;
+		}
+		case "null": return isNull(column);
+		case "notnull": return not(isNull(column));
+		case "in":
+		case "notin": {
+			const expr = inArray(column, require_utils.toArray(value).map((v) => maybeParseNumber(v)));
+			return operatorLC === "notin" ? not(expr) : expr;
+		}
+		case "between":
+		case "notbetween": {
+			const valueAsArray = require_utils.toArray(value);
+			if (valueAsArray.length >= 2 && require_utils.isValidValue(valueAsArray[0]) && require_utils.isValidValue(valueAsArray[1])) {
+				let [first, second] = valueAsArray;
+				const shouldParseNumbers = !(parseNumbers === false);
+				if (!valueIsField && require_utils.shouldRenderAsNumber(first, shouldParseNumbers) && require_utils.shouldRenderAsNumber(second, shouldParseNumbers)) {
+					const firstNum = require_utils.parseNumber(first, { parseNumbers: shouldParseNumbers });
+					const secondNum = require_utils.parseNumber(second, { parseNumbers: shouldParseNumbers });
+					if (!preserveValueOrder && secondNum < firstNum) {
+						const tempNum = secondNum;
+						second = firstNum;
+						first = tempNum;
+					} else {
+						first = firstNum;
+						second = secondNum;
+					}
+				} else if (valueIsField) {
+					first = asFieldOrValue(first);
+					second = asFieldOrValue(second);
+				}
+				const expr = and(gte(column, first), lte(column, second));
+				return operatorLC === "notbetween" ? not(expr) : expr;
+			}
+			return;
+		}
+		default: return;
+	}
+};
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorTanStackDB.ts
+/**
+* Default rule group processor used by {@link formatQuery} for the "tanstack_db" format.
+* Returns a `WhereCallback` suitable for TanStack DB's `.where()` method.
+*
+* @example
+* const where = formatQuery(query, { format: 'tanstack_db', context: { tanstackDb: tsdb } });
+* const results = useLiveQuery(q => q.from({ todo: todosCollection }).where(where));
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorTanStackDB = (ruleGroup, options) => (refs) => {
+	const { fields, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, validateRule, validationMap, context = {} } = options;
+	const ops = context.tanStackDbOperators;
+	if (!ops) return void 0;
+	const { and, eq, not, or } = ops;
+	const fallback = eq(1, 1);
+	const refKeys = Object.keys(refs);
+	/* v8 ignore next -- @preserve */
+	if (refKeys.length === 0) return fallback;
+	const ruleProcessor = defaultRuleProcessorTanStackDB;
+	const processRuleGroup = (rg) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return;
+		const processedRules = rg.rules.map((rule) => {
+			if (require_objectUtils.isRuleGroup(rule)) return processRuleGroup(rule);
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return;
+			const fieldData = require_utils.getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				fieldData,
+				context: {
+					...context,
+					_tanstackDbRefs: refs,
+					_tanstackDbPrimaryRef: refKeys[0]
+				}
+			});
+		}).filter(Boolean);
+		if (processedRules.length === 0) return fallback;
+		const ruleGroupExpr = processedRules.length === 1 ? processedRules[0] : rg.combinator === "or" ? or(...processedRules) : and(...processedRules);
+		return rg.not ? not(ruleGroupExpr) : ruleGroupExpr;
+	};
+	return processRuleGroup(require_convertQuery.convertFromIC(ruleGroup)) ?? fallback;
+};
+//#endregion
 //#region src/utils/formatQuery/defaultRuleGroupProcessorDiagnostics.ts
 const numericInputTypes = new Set([
 	"number",
@@ -2168,6 +2309,8 @@ const defaultValueProcessorNL = (rule, opts = {}) => {
 	const orTL = t.or ?? "or";
 	const trueTL = t.true ?? "true";
 	const falseTL = t.false ?? "false";
+	const listSep = t.listSeparator ?? ", ";
+	const useOxfordComma = !t.listSeparator;
 	switch (operatorLowerCase) {
 		case "null":
 		case "notnull": return "";
@@ -2187,7 +2330,8 @@ const defaultValueProcessorNL = (rule, opts = {}) => {
 			if (valueAsArray.length === 0) return "";
 			const valStringArray = valueAsArray.map((v) => valueIsField ? wrapFieldName(require_utils.getOption(fields ?? [], v)?.label ?? v) : require_utils.shouldRenderAsNumber(v, parseNumbers) ? `${require_utils.trimIfString(v)}` : `${wrapAndEscape(v)}`);
 			if (valStringArray.length === 1) return valStringArray[0];
-			return `(${`${valStringArray.slice(0, -1).join(", ")}${valStringArray.length > 2 ? "," : ""} ${orTL} ${valStringArray.at(-1)}`})`;
+			const oxfordComma = useOxfordComma && valStringArray.length > 2 ? "," : "";
+			return `(${`${valStringArray.slice(0, -1).join(listSep)}${oxfordComma} ${orTL} ${valStringArray.at(-1)}`})`;
 		}
 	}
 	if (typeof rule.value === "boolean") return rule.value ? trueTL : falseTL;
@@ -2300,7 +2444,14 @@ const defaultRuleProcessorNL = (rule, opts) => {
 		V: operatorProcessor(rule, opts),
 		O: value
 	};
-	return require_utils.normalizeConstituentWordOrder(wordOrder).map((term) => `${wordOrderMap[term]}`).join(" ").trim();
+	const translations = opts?.translations ?? {};
+	const suffixMap = {
+		S: translations.afterSubject ?? " ",
+		V: translations.afterVerb ?? " ",
+		O: translations.afterObject ?? " "
+	};
+	const wordOrderTuple = require_utils.normalizeConstituentWordOrder(wordOrder).filter((term) => wordOrderMap[term] !== "");
+	return wordOrderTuple.map((term, i) => `${wordOrderMap[term]}${i < wordOrderTuple.length - 1 ? suffixMap[term] : ""}`).join("").trim();
 };
 //#endregion
 //#region src/utils/formatQuery/defaultRuleProcessorSQL.ts
@@ -2594,6 +2745,11 @@ const defaultRuleProcessorSequelize = (rule, { parseNumbers, preserveValueOrder,
 //#endregion
 //#region src/utils/formatQuery/defaultRuleProcessorSPARQL.ts
 const escapeDoubleQuotes = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`"`, `\\"`);
+/** Auto-prefix a SPARQL variable name with `?` unless it's already prefixed, a URI, or a prefixed name.
+*
+* @group Export
+*/
+const sparqlVar = (name) => /^[?<]/.test(name) || name.includes(":") ? name : `?${name}`;
 /**
 * Default rule processor used by {@link formatQuery} for "sparql" format.
 *
@@ -2601,14 +2757,15 @@ const escapeDoubleQuotes = (v, escapeQuotes) => typeof v !== "string" || !escape
 */
 const defaultRuleProcessorSPARQL = (rule, opts = {}) => {
 	const { escapeQuotes, parseNumbers } = opts;
-	const { field, operator, value, valueSource } = rule;
+	const { field: rawField, operator, value, valueSource } = rule;
 	const valueIsField = valueSource === "field";
 	const operatorTL = operator.toLowerCase();
+	const field = sparqlVar(rawField);
 	const fmtVal = (v) => {
 		if (v === null || v === void 0) return "\"\"";
 		if (typeof v === "boolean") return `"${v}"^^xsd:boolean`;
 		if (typeof v === "bigint") return String(v);
-		if (valueIsField) return require_utils.trimIfString(v);
+		if (valueIsField) return sparqlVar(require_utils.trimIfString(v));
 		if (typeof v === "number" || require_utils.shouldRenderAsNumber(v, parseNumbers)) return require_utils.trimIfString(v);
 		const s = typeof v === "string" ? v : JSON.stringify(v) ?? "";
 		if (s.startsWith("?") || s.startsWith("<") || s.includes(":")) return s;
@@ -2633,12 +2790,12 @@ const defaultRuleProcessorSPARQL = (rule, opts = {}) => {
 		case "in": {
 			const items = require_utils.toArray(value).map(fmtVal);
 			if (!items.length) return "";
-			return items.map((item) => `${field} = ${item}`).join(" || ");
+			return `${field} IN (${items.join(", ")})`;
 		}
 		case "notin": {
 			const items = require_utils.toArray(value).map(fmtVal);
 			if (!items.length) return "";
-			return items.map((item) => `${field} != ${item}`).join(" && ");
+			return `${field} NOT IN (${items.join(", ")})`;
 		}
 		case "between": {
 			const arr = require_utils.toArray(value);
@@ -2701,6 +2858,7 @@ const defaultRuleProcessors = {
 	sequelize: defaultRuleProcessorSequelize,
 	spel: defaultRuleProcessorSpEL,
 	sql: defaultRuleProcessorSQL,
+	tanstack_db: defaultRuleProcessorTanStackDB,
 	cypher: defaultRuleProcessorCypher,
 	gql: defaultRuleProcessorCypher,
 	sparql: defaultRuleProcessorSPARQL,
@@ -2727,6 +2885,7 @@ const defaultOperatorProcessors = {
 	sequelize: defaultOperatorProcessor,
 	spel: defaultOperatorProcessor,
 	sql: defaultOperatorProcessorSQL,
+	tanstack_db: defaultOperatorProcessor,
 	cypher: defaultOperatorProcessor,
 	gql: defaultOperatorProcessor,
 	sparql: defaultOperatorProcessor,
@@ -2773,7 +2932,8 @@ const valueProcessorCanActAsRuleProcessor = new Set([
 	"mongodb",
 	"prisma",
 	"sequelize",
-	"spel"
+	"spel",
+	"tanstack_db"
 ]);
 const sqlFormats = new Set([
 	"sql",
@@ -2819,7 +2979,7 @@ function formatQuery(ruleGroup, optionParam = {}) {
 				} : format === "parameterized_named" ? {
 					sql: fallbackExpression,
 					params: {}
-				} : format === "mongodb" ? `{${fallbackExpression}}` : format === "mongodb_query" ? mongoDbFallback : format === "prisma" ? prismaFallback : format === "jsonlogic" ? false : format === "elasticsearch" ? {} : format === "drizzle" || format === "sequelize" ? void 0 : fallbackExpression;
+				} : format === "mongodb" ? `{${fallbackExpression}}` : format === "mongodb_query" ? mongoDbFallback : format === "prisma" ? prismaFallback : format === "jsonlogic" ? false : format === "elasticsearch" ? {} : format === "drizzle" || format === "sequelize" || format === "tanstack_db" ? void 0 : fallbackExpression;
 			}
 		} else validationMap = validationResult;
 	}
@@ -2879,6 +3039,7 @@ function formatQuery(ruleGroup, optionParam = {}) {
 		case "ldap": return defaultRuleGroupProcessorLDAP(ruleGroup, finalOptions);
 		case "prisma": return defaultRuleGroupProcessorPrisma(ruleGroup, finalOptions);
 		case "drizzle": return defaultRuleGroupProcessorDrizzle(ruleGroup, finalOptions);
+		case "tanstack_db": return defaultRuleGroupProcessorTanStackDB(ruleGroup, finalOptions);
 		case "sequelize": return defaultRuleGroupProcessorSequelize(ruleGroup, finalOptions);
 		case "cypher":
 		case "gql": return defaultRuleGroupProcessorCypher(ruleGroup, finalOptions);
@@ -2967,6 +3128,7 @@ exports.defaultRuleGroupProcessorSPARQL = defaultRuleGroupProcessorSPARQL;
 exports.defaultRuleGroupProcessorSQL = defaultRuleGroupProcessorSQL;
 exports.defaultRuleGroupProcessorSequelize = defaultRuleGroupProcessorSequelize;
 exports.defaultRuleGroupProcessorSpEL = defaultRuleGroupProcessorSpEL;
+exports.defaultRuleGroupProcessorTanStackDB = defaultRuleGroupProcessorTanStackDB;
 exports.defaultRuleProcessorCEL = defaultRuleProcessorCEL;
 exports.defaultRuleProcessorCypher = defaultRuleProcessorCypher;
 exports.defaultRuleProcessorDrizzle = defaultRuleProcessorDrizzle;
@@ -2984,6 +3146,7 @@ exports.defaultRuleProcessorSPARQL = defaultRuleProcessorSPARQL;
 exports.defaultRuleProcessorSQL = defaultRuleProcessorSQL;
 exports.defaultRuleProcessorSequelize = defaultRuleProcessorSequelize;
 exports.defaultRuleProcessorSpEL = defaultRuleProcessorSpEL;
+exports.defaultRuleProcessorTanStackDB = defaultRuleProcessorTanStackDB;
 exports.defaultSpELValueProcessor = defaultSpELValueProcessor;
 exports.defaultValueProcessor = defaultValueProcessor;
 exports.defaultValueProcessorByRule = defaultValueProcessorByRule;
@@ -3008,6 +3171,7 @@ exports.prismaFallback = prismaFallback;
 exports.prismaOperators = require_utils.prismaOperators;
 exports.processMatchMode = require_utils.processMatchMode;
 exports.shouldRenderAsNumber = require_utils.shouldRenderAsNumber;
+exports.sparqlVar = sparqlVar;
 exports.sqlDialectPresets = sqlDialectPresets;
 
 //# sourceMappingURL=formatQuery.js.map