@react-querybuilder/core 8.9.1 → 8.10.0

package/dist/styles/_layout.scss

@@ -84,9 +84,13 @@
 /* #endregion */
 
 /* #region Branches */
-.queryBuilder-branches {
+@mixin branch-layout-styles($direction) {
+  $ltr-after: if($direction == rtl, before, after);
+  $ltr-before: if($direction == rtl, after, before);
+  $margin-side: if($direction == rtl, right, left);
+
   .ruleGroup-body {
-    margin-left: calc(2 * var(--#{$rqb-var-prefix}branch-indent));
+    margin-#{$margin-side}: calc(2 * var(--#{$rqb-var-prefix}branch-indent));
   }
 
   .rule,
@@ -97,26 +101,40 @@
     &::after {
       content: '';
       width: var(--#{$rqb-var-prefix}branch-indent);
-      left: calc(
+      #{$margin-side}: calc(
         -1 * (var(--#{$rqb-var-prefix}branch-indent) + var(--#{$rqb-var-prefix}branch-width))
       );
       border-radius: 0;
       position: absolute;
     }
 
-    &::before {
+    &::#{$ltr-before} {
       top: calc(-1 * var(--#{$rqb-var-prefix}spacing));
       height: calc(50% + var(--#{$rqb-var-prefix}spacing));
-      border-width: 0 0 var(--#{$rqb-var-prefix}branch-width) var(--#{$rqb-var-prefix}branch-width);
+      @if $direction == rtl {
+        border-width: 0
+          var(--#{$rqb-var-prefix}branch-width)
+          var(--#{$rqb-var-prefix}branch-width)
+          0;
+      } @else {
+        border-width: 0
+          0
+          var(--#{$rqb-var-prefix}branch-width)
+          var(--#{$rqb-var-prefix}branch-width);
+      }
     }
 
-    &::after {
+    &::#{$ltr-after} {
       top: 50%;
       height: 50%;
-      border-width: 0 0 0 var(--#{$rqb-var-prefix}branch-width);
+      @if $direction == rtl {
+        border-width: 0 var(--#{$rqb-var-prefix}branch-width) 0 0;
+      } @else {
+        border-width: 0 0 0 var(--#{$rqb-var-prefix}branch-width);
+      }
     }
 
-    &:last-child::after {
+    &:last-child::#{$ltr-after} {
       display: none;
     }
   }
@@ -125,7 +143,7 @@
   .ruleGroup .ruleGroup {
     &::before,
     &::after {
-      left: calc(
+      #{$margin-side}: calc(
         -1 *
           (
             var(--#{$rqb-var-prefix}branch-indent) + var(--#{$rqb-var-prefix}branch-width) +
@@ -134,12 +152,12 @@
       );
     }
 
-    &::before {
+    &::#{$ltr-before} {
       top: calc(-1 * (var(--#{$rqb-var-prefix}spacing) + var(--#{$rqb-var-prefix}border-width)));
       height: calc(50% + var(--#{$rqb-var-prefix}spacing) + var(--#{$rqb-var-prefix}border-width));
     }
 
-    &::after {
+    &::#{$ltr-after} {
       height: calc(50% + var(--#{$rqb-var-prefix}border-width));
     }
   }
@@ -147,24 +165,40 @@
   .betweenRules {
     position: relative;
 
-    &::before {
+    &::#{$ltr-before} {
       content: '';
       width: var(--#{$rqb-var-prefix}branch-indent);
-      left: calc(
+      #{$margin-side}: calc(
         -1 * (var(--#{$rqb-var-prefix}branch-indent) + var(--#{$rqb-var-prefix}branch-width))
       );
       border-radius: 0;
       position: absolute;
       top: calc(-1 * var(--#{$rqb-var-prefix}spacing));
       height: calc(100% + var(--#{$rqb-var-prefix}spacing));
-      border-width: 0 0 0 var(--#{$rqb-var-prefix}branch-width);
+      @if $direction == rtl {
+        border-width: 0 var(--#{$rqb-var-prefix}branch-width) 0 0;
+      } @else {
+        border-width: 0 0 0 var(--#{$rqb-var-prefix}branch-width);
+      }
     }
   }
 }
+
+/* LTR */
+.queryBuilder-branches:dir(ltr) {
+  @include branch-layout-styles(ltr);
+}
+
+/* RTL */
+.queryBuilder-branches:dir(rtl) {
+  @include branch-layout-styles(rtl);
+}
 /* #endregion */
 
 /* #region Justified */
-.queryBuilder-justified {
+@mixin justified-auto-margin($direction) {
+  $margin-side: if($direction == rtl, right, left);
+
   .ruleGroup-combinators,
   .ruleGroup-notToggle,
   .shiftActions,
@@ -187,15 +221,25 @@
     & + .rule-cloneRule,
     & + .rule-lock,
     & + .rule-remove {
-      margin-left: auto !important;
+      margin-#{$margin-side}: auto !important;
     }
   }
 
   .ruleGroup-addRule,
   .ruleGroup-addGroup {
     &:first-child {
-      margin-left: auto !important;
+      margin-#{$margin-side}: auto !important;
     }
   }
 }
+
+/* LTR */
+.queryBuilder-justified:dir(ltr) {
+  @include justified-auto-margin(ltr);
+}
+
+/* RTL */
+.queryBuilder-justified:dir(rtl) {
+  @include justified-auto-margin(rtl);
+}
 /* #endregion */

package/dist/styles/_main.scss

@@ -88,7 +88,10 @@
 /* #endregion */
 
 /* #region Branch styles */
-.queryBuilder-branches {
+@mixin branch-styles($direction) {
+  $before-after: if($direction == rtl, after, before);
+  $border-side: if($direction == rtl, right, left);
+
   .rule,
   .ruleGroup .ruleGroup {
     &::before,
@@ -97,18 +100,28 @@
       border-style: var(--#{$rqb-var-prefix}branch-style);
     }
 
-    &:last-child::before {
-      border-bottom-left-radius: var(--#{$rqb-var-prefix}branch-radius);
+    &:last-child::#{$before-after} {
+      border-bottom-#{$border-side}-radius: var(--#{$rqb-var-prefix}branch-radius);
     }
   }
 
   .betweenRules {
     position: relative;
 
-    &::before {
+    &::#{$before-after} {
       border-color: var(--#{$rqb-var-prefix}branch-color);
       border-style: var(--#{$rqb-var-prefix}branch-style);
     }
   }
 }
+
+/* LTR */
+.queryBuilder-branches:dir(ltr) {
+  @include branch-styles(ltr);
+}
+
+/* RTL */
+.queryBuilder-branches:dir(rtl) {
+  @include branch-styles(rtl);
+}
 /* #endregion */

package/dist/{transformQuery-FL_nlpp5.js → transformQuery-CWDPogO5.js}

@@ -44,4 +44,4 @@ Object.defineProperty(exports, 'transformQuery', {
     return transformQuery;
   }
 });
-//# sourceMappingURL=transformQuery-FL_nlpp5.js.map
+//# sourceMappingURL=transformQuery-CWDPogO5.js.map

package/dist/{transformQuery-FL_nlpp5.js.map → transformQuery-CWDPogO5.js.map}

@@ -1 +1 @@
-{"version":3,"file":"transformQuery-FL_nlpp5.js","names":["isRuleGroupType","isRuleGroup"],"sources":["../src/utils/transformQuery.ts"],"sourcesContent":["/**\n * Recursively steps through a query object ({@link index!RuleGroupType RuleGroupType} or {@link index!RuleGroupTypeIC RuleGroupTypeIC}),\n * passing each {@link index!RuleType RuleType} object to a provided `ruleProcessor` function and returning a\n * new query object if there were any referential changes.\n *\n * @module transformQuery\n */\n\nimport { produce } from 'immer';\nimport type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isRuleGroup, isRuleGroupType } from './isRuleGroup';\n\nconst remapProperties = (\n  // oxlint-disable-next-line typescript/no-explicit-any\n  obj: Record<string, any>,\n  propertyMap: Record<string, string | false>,\n  deleteRemappedProperties: boolean\n) =>\n  produce(obj, draft => {\n    for (const [k, v] of Object.entries(propertyMap)) {\n      if (v === false) {\n        delete draft[k];\n      } else if (!!v && k !== v && k in draft) {\n        draft[v] = draft[k];\n        if (deleteRemappedProperties) {\n          delete draft[k];\n        }\n      }\n    }\n  });\n\n/**\n * Options object for {@link index!transformQuery transformQuery}.\n */\nexport interface TransformQueryOptions<RG extends RuleGroupTypeAny = RuleGroupType> {\n  /**\n   * When a rule is encountered in the hierarchy, it will be replaced\n   * with the result of this function.\n   *\n   * @defaultValue `r => r`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleProcessor?: (rule: RuleType) => any;\n  /**\n   * When a group is encountered in the hierarchy (including the root group, the\n   * query itself), it will be replaced with the result of this function.\n   *\n   * @defaultValue `rg => rg`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleGroupProcessor?: (ruleGroup: RG) => Record<string, any>;\n  /**\n   * For each rule and group in the query, any properties matching a key\n   * in this object will be renamed to the corresponding value. To retain both\n   * the new _and_ the original properties, set `deleteRemappedProperties`\n   * to `false`.\n   *\n   * If a key has a value of `false`, the corresponding property will be removed\n   * without being copied to a new property name. (Warning: `{ rules: false }`\n   * will prevent recursion and only return the processed root group.)\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', not: true, rules: [] },\n   *     { propertyMap: { combinator: 'AndOr', not: false } }\n   *   )\n   *   // Returns: { AndOr: 'and', rules: [] }\n   * ```\n   */\n  propertyMap?: Record<string, string | false>;\n  /**\n   * Any combinator values (including independent combinators) will be translated\n   * from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { combinatorMap: { and: '&&', or: '||' } }\n   *   )\n   *   // Returns: { combinator: '&&', rules: [] }\n   * ```\n   */\n  combinatorMap?: Record<string, string>;\n  /**\n   * Any operator values will be translated from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [{ field: 'name', operator: '=', value: 'Steve Vai' }] },\n   *     { operatorMap: { '=': 'is' } }\n   *   )\n   *   // Returns:\n   *   // {\n   *   //   combinator: 'and',\n   *   //   rules: [{ field: 'name', operator: 'is', value: 'Steve Vai' }]\n   *   // }\n   * ```\n   */\n  operatorMap?: Record<string, string>;\n  /**\n   * Prevents the `path` property (see {@link index!Path Path}) from being added to each\n   * rule and group in the hierarchy.\n   *\n   * @defaultValue `false`\n   */\n  omitPath?: boolean;\n  /**\n   * Original properties remapped according to the `propertyMap` option will be removed.\n   *\n   * @defaultValue `true`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { propertyMap: { combinator: 'AndOr' }, deleteRemappedProperties: false }\n   *   )\n   *   // Returns: { combinator: 'and', AndOr: 'and', rules: [] }\n   * ```\n   */\n  deleteRemappedProperties?: boolean;\n}\n\n/**\n * Recursively process a query heirarchy using this versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupType,\n  options?: TransformQueryOptions\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\n/**\n * Recursively process a query heirarchy with independent combinators using this\n * versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupTypeIC,\n  options?: TransformQueryOptions<RuleGroupTypeIC>\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\nexport function transformQuery<RG extends RuleGroupTypeAny>(\n  query: RG,\n  options: TransformQueryOptions<RG> = {}\n) {\n  const {\n    ruleProcessor = r => r,\n    ruleGroupProcessor = rg => rg,\n    propertyMap = {},\n    combinatorMap = {},\n    operatorMap = {},\n    omitPath = false,\n    deleteRemappedProperties = true,\n  } = options;\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  const processGroup = (rg: RuleGroupTypeAny): any => ({\n    ...ruleGroupProcessor(\n      remapProperties(\n        {\n          ...rg,\n          ...(isRuleGroupType(rg)\n            ? { combinator: combinatorMap[rg.combinator] ?? rg.combinator }\n            : {}),\n        },\n        propertyMap,\n        deleteRemappedProperties\n      ) as RG\n    ),\n    ...(propertyMap['rules'] === false\n      ? null\n      : {\n          // oxlint-disable-next-line typescript/no-explicit-any\n          [propertyMap['rules'] ?? 'rules']: rg.rules.map((r: any, idx) => {\n            const pathObject = omitPath ? null : { path: [...rg.path!, idx] };\n            if (typeof r === 'string') {\n              // independent combinators\n              return combinatorMap[r] ?? r;\n            } else if (isRuleGroup(r)) {\n              // sub-groups\n              return processGroup({ ...r, ...pathObject });\n            }\n            // rules\n            return ruleProcessor(\n              remapProperties(\n                {\n                  ...r,\n                  ...pathObject,\n                  ...('operator' in r ? { operator: operatorMap[r.operator] ?? r.operator } : {}),\n                },\n                propertyMap,\n                deleteRemappedProperties\n              ) as RuleType\n            );\n          }),\n        }),\n  });\n\n  return processGroup({ ...query, ...(omitPath ? null : { path: [] }) });\n}\n"],"mappings":";;;;;AAYA,MAAM,mBAEJ,KACA,aACA,gDAEQ,MAAK,UAAS;AACpB,MAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,YAAY,CAC9C,KAAI,MAAM,MACR,QAAO,MAAM;UACJ,CAAC,CAAC,KAAK,MAAM,KAAK,KAAK,OAAO;AACvC,QAAM,KAAK,MAAM;AACjB,MAAI,yBACF,QAAO,MAAM;;EAInB;AA4HJ,SAAgB,eACd,OACA,UAAqC,EAAE,EACvC;CACA,MAAM,EACJ,iBAAgB,MAAK,GACrB,sBAAqB,OAAM,IAC3B,cAAc,EAAE,EAChB,gBAAgB,EAAE,EAClB,cAAc,EAAE,EAChB,WAAW,OACX,2BAA2B,SACzB;CAGJ,MAAM,gBAAgB,QAA+B;EACnD,GAAG,mBACD,gBACE;GACE,GAAG;GACH,GAAIA,oCAAgB,GAAG,GACnB,EAAE,YAAY,cAAc,GAAG,eAAe,GAAG,YAAY,GAC7D,EAAE;GACP,EACD,aACA,yBACD,CACF;EACD,GAAI,YAAY,aAAa,QACzB,OACA,GAEG,YAAY,YAAY,UAAU,GAAG,MAAM,KAAK,GAAQ,QAAQ;GAC/D,MAAM,aAAa,WAAW,OAAO,EAAE,MAAM,CAAC,GAAG,GAAG,MAAO,IAAI,EAAE;AACjE,OAAI,OAAO,MAAM,SAEf,QAAO,cAAc,MAAM;YAClBC,gCAAY,EAAE,CAEvB,QAAO,aAAa;IAAE,GAAG;IAAG,GAAG;IAAY,CAAC;AAG9C,UAAO,cACL,gBACE;IACE,GAAG;IACH,GAAG;IACH,GAAI,cAAc,IAAI,EAAE,UAAU,YAAY,EAAE,aAAa,EAAE,UAAU,GAAG,EAAE;IAC/E,EACD,aACA,yBACD,CACF;IACD,EACH;EACN;AAED,QAAO,aAAa;EAAE,GAAG;EAAO,GAAI,WAAW,OAAO,EAAE,MAAM,EAAE,EAAE;EAAG,CAAC"}
+{"version":3,"file":"transformQuery-CWDPogO5.js","names":["isRuleGroupType","isRuleGroup"],"sources":["../src/utils/transformQuery.ts"],"sourcesContent":["/**\n * Recursively steps through a query object ({@link index!RuleGroupType RuleGroupType} or {@link index!RuleGroupTypeIC RuleGroupTypeIC}),\n * passing each {@link index!RuleType RuleType} object to a provided `ruleProcessor` function and returning a\n * new query object if there were any referential changes.\n *\n * @module transformQuery\n */\n\nimport { produce } from 'immer';\nimport type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isRuleGroup, isRuleGroupType } from './isRuleGroup';\n\nconst remapProperties = (\n  // oxlint-disable-next-line typescript/no-explicit-any\n  obj: Record<string, any>,\n  propertyMap: Record<string, string | false>,\n  deleteRemappedProperties: boolean\n) =>\n  produce(obj, draft => {\n    for (const [k, v] of Object.entries(propertyMap)) {\n      if (v === false) {\n        delete draft[k];\n      } else if (!!v && k !== v && k in draft) {\n        draft[v] = draft[k];\n        if (deleteRemappedProperties) {\n          delete draft[k];\n        }\n      }\n    }\n  });\n\n/**\n * Options object for {@link index!transformQuery transformQuery}.\n */\nexport interface TransformQueryOptions<RG extends RuleGroupTypeAny = RuleGroupType> {\n  /**\n   * When a rule is encountered in the hierarchy, it will be replaced\n   * with the result of this function.\n   *\n   * @defaultValue `r => r`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleProcessor?: (rule: RuleType) => any;\n  /**\n   * When a group is encountered in the hierarchy (including the root group, the\n   * query itself), it will be replaced with the result of this function.\n   *\n   * @defaultValue `rg => rg`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleGroupProcessor?: (ruleGroup: RG) => Record<string, any>;\n  /**\n   * For each rule and group in the query, any properties matching a key\n   * in this object will be renamed to the corresponding value. To retain both\n   * the new _and_ the original properties, set `deleteRemappedProperties`\n   * to `false`.\n   *\n   * If a key has a value of `false`, the corresponding property will be removed\n   * without being copied to a new property name. (Warning: `{ rules: false }`\n   * will prevent recursion and only return the processed root group.)\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', not: true, rules: [] },\n   *     { propertyMap: { combinator: 'AndOr', not: false } }\n   *   )\n   *   // Returns: { AndOr: 'and', rules: [] }\n   * ```\n   */\n  propertyMap?: Record<string, string | false>;\n  /**\n   * Any combinator values (including independent combinators) will be translated\n   * from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { combinatorMap: { and: '&&', or: '||' } }\n   *   )\n   *   // Returns: { combinator: '&&', rules: [] }\n   * ```\n   */\n  combinatorMap?: Record<string, string>;\n  /**\n   * Any operator values will be translated from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [{ field: 'name', operator: '=', value: 'Steve Vai' }] },\n   *     { operatorMap: { '=': 'is' } }\n   *   )\n   *   // Returns:\n   *   // {\n   *   //   combinator: 'and',\n   *   //   rules: [{ field: 'name', operator: 'is', value: 'Steve Vai' }]\n   *   // }\n   * ```\n   */\n  operatorMap?: Record<string, string>;\n  /**\n   * Prevents the `path` property (see {@link index!Path Path}) from being added to each\n   * rule and group in the hierarchy.\n   *\n   * @defaultValue `false`\n   */\n  omitPath?: boolean;\n  /**\n   * Original properties remapped according to the `propertyMap` option will be removed.\n   *\n   * @defaultValue `true`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { propertyMap: { combinator: 'AndOr' }, deleteRemappedProperties: false }\n   *   )\n   *   // Returns: { combinator: 'and', AndOr: 'and', rules: [] }\n   * ```\n   */\n  deleteRemappedProperties?: boolean;\n}\n\n/**\n * Recursively process a query heirarchy using this versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupType,\n  options?: TransformQueryOptions\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\n/**\n * Recursively process a query heirarchy with independent combinators using this\n * versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupTypeIC,\n  options?: TransformQueryOptions<RuleGroupTypeIC>\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\nexport function transformQuery<RG extends RuleGroupTypeAny>(\n  query: RG,\n  options: TransformQueryOptions<RG> = {}\n) {\n  const {\n    ruleProcessor = r => r,\n    ruleGroupProcessor = rg => rg,\n    propertyMap = {},\n    combinatorMap = {},\n    operatorMap = {},\n    omitPath = false,\n    deleteRemappedProperties = true,\n  } = options;\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  const processGroup = (rg: RuleGroupTypeAny): any => ({\n    ...ruleGroupProcessor(\n      remapProperties(\n        {\n          ...rg,\n          ...(isRuleGroupType(rg)\n            ? { combinator: combinatorMap[rg.combinator] ?? rg.combinator }\n            : {}),\n        },\n        propertyMap,\n        deleteRemappedProperties\n      ) as RG\n    ),\n    ...(propertyMap['rules'] === false\n      ? null\n      : {\n          // oxlint-disable-next-line typescript/no-explicit-any\n          [propertyMap['rules'] ?? 'rules']: rg.rules.map((r: any, idx) => {\n            const pathObject = omitPath ? null : { path: [...rg.path!, idx] };\n            if (typeof r === 'string') {\n              // independent combinators\n              return combinatorMap[r] ?? r;\n            } else if (isRuleGroup(r)) {\n              // sub-groups\n              return processGroup({ ...r, ...pathObject });\n            }\n            // rules\n            return ruleProcessor(\n              remapProperties(\n                {\n                  ...r,\n                  ...pathObject,\n                  ...('operator' in r ? { operator: operatorMap[r.operator] ?? r.operator } : {}),\n                },\n                propertyMap,\n                deleteRemappedProperties\n              ) as RuleType\n            );\n          }),\n        }),\n  });\n\n  return processGroup({ ...query, ...(omitPath ? null : { path: [] }) });\n}\n"],"mappings":";;;;;AAYA,MAAM,mBAEJ,KACA,aACA,gDAEQ,MAAK,UAAS;AACpB,MAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,YAAY,CAC9C,KAAI,MAAM,MACR,QAAO,MAAM;UACJ,CAAC,CAAC,KAAK,MAAM,KAAK,KAAK,OAAO;AACvC,QAAM,KAAK,MAAM;AACjB,MAAI,yBACF,QAAO,MAAM;;EAInB;AA4HJ,SAAgB,eACd,OACA,UAAqC,EAAE,EACvC;CACA,MAAM,EACJ,iBAAgB,MAAK,GACrB,sBAAqB,OAAM,IAC3B,cAAc,EAAE,EAChB,gBAAgB,EAAE,EAClB,cAAc,EAAE,EAChB,WAAW,OACX,2BAA2B,SACzB;CAGJ,MAAM,gBAAgB,QAA+B;EACnD,GAAG,mBACD,gBACE;GACE,GAAG;GACH,GAAIA,oCAAgB,GAAG,GACnB,EAAE,YAAY,cAAc,GAAG,eAAe,GAAG,YAAY,GAC7D,EAAE;GACP,EACD,aACA,yBACD,CACF;EACD,GAAI,YAAY,aAAa,QACzB,OACA,GAEG,YAAY,YAAY,UAAU,GAAG,MAAM,KAAK,GAAQ,QAAQ;GAC/D,MAAM,aAAa,WAAW,OAAO,EAAE,MAAM,CAAC,GAAG,GAAG,MAAO,IAAI,EAAE;AACjE,OAAI,OAAO,MAAM,SAEf,QAAO,cAAc,MAAM;YAClBC,gCAAY,EAAE,CAEvB,QAAO,aAAa;IAAE,GAAG;IAAG,GAAG;IAAY,CAAC;AAG9C,UAAO,cACL,gBACE;IACE,GAAG;IACH,GAAG;IACH,GAAI,cAAc,IAAI,EAAE,UAAU,YAAY,EAAE,aAAa,EAAE,UAAU,GAAG,EAAE;IAC/E,EACD,aACA,yBACD,CACF;IACD,EACH;EACN;AAED,QAAO,aAAa;EAAE,GAAG;EAAO,GAAI,WAAW,OAAO,EAAE,MAAM,EAAE,EAAE;EAAG,CAAC"}

package/dist/transformQuery-DHvtgDgZ.mjs

@@ -0,0 +1,41 @@
+import { isRuleGroup, isRuleGroupType } from "./isRuleGroup-CGe_rb2w.mjs";
+import { produce } from "immer";
+
+//#region src/utils/transformQuery.ts
+const remapProperties = (obj, propertyMap, deleteRemappedProperties) => produce(obj, (draft) => {
+	for (const [k, v] of Object.entries(propertyMap)) if (v === false) delete draft[k];
+	else if (!!v && k !== v && k in draft) {
+		draft[v] = draft[k];
+		if (deleteRemappedProperties) delete draft[k];
+	}
+});
+function transformQuery(query, options = {}) {
+	const { ruleProcessor = (r) => r, ruleGroupProcessor = (rg) => rg, propertyMap = {}, combinatorMap = {}, operatorMap = {}, omitPath = false, deleteRemappedProperties = true } = options;
+	const processGroup = (rg) => ({
+		...ruleGroupProcessor(remapProperties({
+			...rg,
+			...isRuleGroupType(rg) ? { combinator: combinatorMap[rg.combinator] ?? rg.combinator } : {}
+		}, propertyMap, deleteRemappedProperties)),
+		...propertyMap["rules"] === false ? null : { [propertyMap["rules"] ?? "rules"]: rg.rules.map((r, idx) => {
+			const pathObject = omitPath ? null : { path: [...rg.path, idx] };
+			if (typeof r === "string") return combinatorMap[r] ?? r;
+			else if (isRuleGroup(r)) return processGroup({
+				...r,
+				...pathObject
+			});
+			return ruleProcessor(remapProperties({
+				...r,
+				...pathObject,
+				..."operator" in r ? { operator: operatorMap[r.operator] ?? r.operator } : {}
+			}, propertyMap, deleteRemappedProperties));
+		}) }
+	});
+	return processGroup({
+		...query,
+		...omitPath ? null : { path: [] }
+	});
+}
+
+//#endregion
+export { transformQuery };
+//# sourceMappingURL=transformQuery-DHvtgDgZ.mjs.map

package/dist/transformQuery-DHvtgDgZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformQuery-DHvtgDgZ.mjs","names":[],"sources":["../src/utils/transformQuery.ts"],"sourcesContent":["/**\n * Recursively steps through a query object ({@link index!RuleGroupType RuleGroupType} or {@link index!RuleGroupTypeIC RuleGroupTypeIC}),\n * passing each {@link index!RuleType RuleType} object to a provided `ruleProcessor` function and returning a\n * new query object if there were any referential changes.\n *\n * @module transformQuery\n */\n\nimport { produce } from 'immer';\nimport type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isRuleGroup, isRuleGroupType } from './isRuleGroup';\n\nconst remapProperties = (\n  // oxlint-disable-next-line typescript/no-explicit-any\n  obj: Record<string, any>,\n  propertyMap: Record<string, string | false>,\n  deleteRemappedProperties: boolean\n) =>\n  produce(obj, draft => {\n    for (const [k, v] of Object.entries(propertyMap)) {\n      if (v === false) {\n        delete draft[k];\n      } else if (!!v && k !== v && k in draft) {\n        draft[v] = draft[k];\n        if (deleteRemappedProperties) {\n          delete draft[k];\n        }\n      }\n    }\n  });\n\n/**\n * Options object for {@link index!transformQuery transformQuery}.\n */\nexport interface TransformQueryOptions<RG extends RuleGroupTypeAny = RuleGroupType> {\n  /**\n   * When a rule is encountered in the hierarchy, it will be replaced\n   * with the result of this function.\n   *\n   * @defaultValue `r => r`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleProcessor?: (rule: RuleType) => any;\n  /**\n   * When a group is encountered in the hierarchy (including the root group, the\n   * query itself), it will be replaced with the result of this function.\n   *\n   * @defaultValue `rg => rg`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleGroupProcessor?: (ruleGroup: RG) => Record<string, any>;\n  /**\n   * For each rule and group in the query, any properties matching a key\n   * in this object will be renamed to the corresponding value. To retain both\n   * the new _and_ the original properties, set `deleteRemappedProperties`\n   * to `false`.\n   *\n   * If a key has a value of `false`, the corresponding property will be removed\n   * without being copied to a new property name. (Warning: `{ rules: false }`\n   * will prevent recursion and only return the processed root group.)\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', not: true, rules: [] },\n   *     { propertyMap: { combinator: 'AndOr', not: false } }\n   *   )\n   *   // Returns: { AndOr: 'and', rules: [] }\n   * ```\n   */\n  propertyMap?: Record<string, string | false>;\n  /**\n   * Any combinator values (including independent combinators) will be translated\n   * from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { combinatorMap: { and: '&&', or: '||' } }\n   *   )\n   *   // Returns: { combinator: '&&', rules: [] }\n   * ```\n   */\n  combinatorMap?: Record<string, string>;\n  /**\n   * Any operator values will be translated from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [{ field: 'name', operator: '=', value: 'Steve Vai' }] },\n   *     { operatorMap: { '=': 'is' } }\n   *   )\n   *   // Returns:\n   *   // {\n   *   //   combinator: 'and',\n   *   //   rules: [{ field: 'name', operator: 'is', value: 'Steve Vai' }]\n   *   // }\n   * ```\n   */\n  operatorMap?: Record<string, string>;\n  /**\n   * Prevents the `path` property (see {@link index!Path Path}) from being added to each\n   * rule and group in the hierarchy.\n   *\n   * @defaultValue `false`\n   */\n  omitPath?: boolean;\n  /**\n   * Original properties remapped according to the `propertyMap` option will be removed.\n   *\n   * @defaultValue `true`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { propertyMap: { combinator: 'AndOr' }, deleteRemappedProperties: false }\n   *   )\n   *   // Returns: { combinator: 'and', AndOr: 'and', rules: [] }\n   * ```\n   */\n  deleteRemappedProperties?: boolean;\n}\n\n/**\n * Recursively process a query heirarchy using this versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupType,\n  options?: TransformQueryOptions\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\n/**\n * Recursively process a query heirarchy with independent combinators using this\n * versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupTypeIC,\n  options?: TransformQueryOptions<RuleGroupTypeIC>\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\nexport function transformQuery<RG extends RuleGroupTypeAny>(\n  query: RG,\n  options: TransformQueryOptions<RG> = {}\n) {\n  const {\n    ruleProcessor = r => r,\n    ruleGroupProcessor = rg => rg,\n    propertyMap = {},\n    combinatorMap = {},\n    operatorMap = {},\n    omitPath = false,\n    deleteRemappedProperties = true,\n  } = options;\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  const processGroup = (rg: RuleGroupTypeAny): any => ({\n    ...ruleGroupProcessor(\n      remapProperties(\n        {\n          ...rg,\n          ...(isRuleGroupType(rg)\n            ? { combinator: combinatorMap[rg.combinator] ?? rg.combinator }\n            : {}),\n        },\n        propertyMap,\n        deleteRemappedProperties\n      ) as RG\n    ),\n    ...(propertyMap['rules'] === false\n      ? null\n      : {\n          // oxlint-disable-next-line typescript/no-explicit-any\n          [propertyMap['rules'] ?? 'rules']: rg.rules.map((r: any, idx) => {\n            const pathObject = omitPath ? null : { path: [...rg.path!, idx] };\n            if (typeof r === 'string') {\n              // independent combinators\n              return combinatorMap[r] ?? r;\n            } else if (isRuleGroup(r)) {\n              // sub-groups\n              return processGroup({ ...r, ...pathObject });\n            }\n            // rules\n            return ruleProcessor(\n              remapProperties(\n                {\n                  ...r,\n                  ...pathObject,\n                  ...('operator' in r ? { operator: operatorMap[r.operator] ?? r.operator } : {}),\n                },\n                propertyMap,\n                deleteRemappedProperties\n              ) as RuleType\n            );\n          }),\n        }),\n  });\n\n  return processGroup({ ...query, ...(omitPath ? null : { path: [] }) });\n}\n"],"mappings":";;;;AAYA,MAAM,mBAEJ,KACA,aACA,6BAEA,QAAQ,MAAK,UAAS;AACpB,MAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,YAAY,CAC9C,KAAI,MAAM,MACR,QAAO,MAAM;UACJ,CAAC,CAAC,KAAK,MAAM,KAAK,KAAK,OAAO;AACvC,QAAM,KAAK,MAAM;AACjB,MAAI,yBACF,QAAO,MAAM;;EAInB;AA4HJ,SAAgB,eACd,OACA,UAAqC,EAAE,EACvC;CACA,MAAM,EACJ,iBAAgB,MAAK,GACrB,sBAAqB,OAAM,IAC3B,cAAc,EAAE,EAChB,gBAAgB,EAAE,EAClB,cAAc,EAAE,EAChB,WAAW,OACX,2BAA2B,SACzB;CAGJ,MAAM,gBAAgB,QAA+B;EACnD,GAAG,mBACD,gBACE;GACE,GAAG;GACH,GAAI,gBAAgB,GAAG,GACnB,EAAE,YAAY,cAAc,GAAG,eAAe,GAAG,YAAY,GAC7D,EAAE;GACP,EACD,aACA,yBACD,CACF;EACD,GAAI,YAAY,aAAa,QACzB,OACA,GAEG,YAAY,YAAY,UAAU,GAAG,MAAM,KAAK,GAAQ,QAAQ;GAC/D,MAAM,aAAa,WAAW,OAAO,EAAE,MAAM,CAAC,GAAG,GAAG,MAAO,IAAI,EAAE;AACjE,OAAI,OAAO,MAAM,SAEf,QAAO,cAAc,MAAM;YAClB,YAAY,EAAE,CAEvB,QAAO,aAAa;IAAE,GAAG;IAAG,GAAG;IAAY,CAAC;AAG9C,UAAO,cACL,gBACE;IACE,GAAG;IACH,GAAG;IACH,GAAI,cAAc,IAAI,EAAE,UAAU,YAAY,EAAE,aAAa,EAAE,UAAU,GAAG,EAAE;IAC/E,EACD,aACA,yBACD,CACF;IACD,EACH;EACN;AAED,QAAO,aAAa;EAAE,GAAG;EAAO,GAAI,WAAW,OAAO,EAAE,MAAM,EAAE,EAAE;EAAG,CAAC"}

package/dist/transformQuery.d.mts

@@ -0,0 +1,118 @@
+import { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from "./basic-BmpEwexQ.mjs";
+
+//#region src/utils/transformQuery.d.ts
+
+/**
+* Options object for {@link index!transformQuery transformQuery}.
+*/
+interface TransformQueryOptions<RG extends RuleGroupTypeAny = RuleGroupType> {
+  /**
+  * When a rule is encountered in the hierarchy, it will be replaced
+  * with the result of this function.
+  *
+  * @defaultValue `r => r`
+  */
+  ruleProcessor?: (rule: RuleType) => any;
+  /**
+  * When a group is encountered in the hierarchy (including the root group, the
+  * query itself), it will be replaced with the result of this function.
+  *
+  * @defaultValue `rg => rg`
+  */
+  ruleGroupProcessor?: (ruleGroup: RG) => Record<string, any>;
+  /**
+  * For each rule and group in the query, any properties matching a key
+  * in this object will be renamed to the corresponding value. To retain both
+  * the new _and_ the original properties, set `deleteRemappedProperties`
+  * to `false`.
+  *
+  * If a key has a value of `false`, the corresponding property will be removed
+  * without being copied to a new property name. (Warning: `{ rules: false }`
+  * will prevent recursion and only return the processed root group.)
+  *
+  * @defaultValue `{}`
+  *
+  * @example
+  * ```
+  *   transformQuery(
+  *     { combinator: 'and', not: true, rules: [] },
+  *     { propertyMap: { combinator: 'AndOr', not: false } }
+  *   )
+  *   // Returns: { AndOr: 'and', rules: [] }
+  * ```
+  */
+  propertyMap?: Record<string, string | false>;
+  /**
+  * Any combinator values (including independent combinators) will be translated
+  * from the key in this object to the value.
+  *
+  * @defaultValue `{}`
+  *
+  * @example
+  * ```
+  *   transformQuery(
+  *     { combinator: 'and', rules: [] },
+  *     { combinatorMap: { and: '&&', or: '||' } }
+  *   )
+  *   // Returns: { combinator: '&&', rules: [] }
+  * ```
+  */
+  combinatorMap?: Record<string, string>;
+  /**
+  * Any operator values will be translated from the key in this object to the value.
+  *
+  * @defaultValue `{}`
+  *
+  * @example
+  * ```
+  *   transformQuery(
+  *     { combinator: 'and', rules: [{ field: 'name', operator: '=', value: 'Steve Vai' }] },
+  *     { operatorMap: { '=': 'is' } }
+  *   )
+  *   // Returns:
+  *   // {
+  *   //   combinator: 'and',
+  *   //   rules: [{ field: 'name', operator: 'is', value: 'Steve Vai' }]
+  *   // }
+  * ```
+  */
+  operatorMap?: Record<string, string>;
+  /**
+  * Prevents the `path` property (see {@link index!Path Path}) from being added to each
+  * rule and group in the hierarchy.
+  *
+  * @defaultValue `false`
+  */
+  omitPath?: boolean;
+  /**
+  * Original properties remapped according to the `propertyMap` option will be removed.
+  *
+  * @defaultValue `true`
+  *
+  * @example
+  * ```
+  *   transformQuery(
+  *     { combinator: 'and', rules: [] },
+  *     { propertyMap: { combinator: 'AndOr' }, deleteRemappedProperties: false }
+  *   )
+  *   // Returns: { combinator: 'and', AndOr: 'and', rules: [] }
+  * ```
+  */
+  deleteRemappedProperties?: boolean;
+}
+/**
+* Recursively process a query heirarchy using this versatile utility function.
+*
+* [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)
+*/
+declare function transformQuery(query: RuleGroupType, options?: TransformQueryOptions): any;
+/**
+* Recursively process a query heirarchy with independent combinators using this
+* versatile utility function.
+*
+* [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)
+*/
+declare function transformQuery(query: RuleGroupTypeIC, options?: TransformQueryOptions<RuleGroupTypeIC>): any;
+//#endregion
+export { TransformQueryOptions, transformQuery };
+//# sourceMappingURL=transformQuery.d.mts.map

package/dist/transformQuery.d.ts

@@ -1,4 +1,4 @@
-import { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from "./basic-C8xXKHIA.js";
+import { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from "./basic-CDDA-KZa.js";
 
 //#region src/utils/transformQuery.d.ts
 

package/dist/transformQuery.js

@@ -1,4 +1,4 @@
 require('./isRuleGroup-DqAs2x4E.js');
-const require_transformQuery = require('./transformQuery-FL_nlpp5.js');
+const require_transformQuery = require('./transformQuery-CWDPogO5.js');
 
 exports.transformQuery = require_transformQuery.transformQuery;

package/dist/transformQuery.mjs

@@ -0,0 +1,4 @@
+import "./isRuleGroup-CGe_rb2w.mjs";
+import { transformQuery } from "./transformQuery-DHvtgDgZ.mjs";
+
+export { transformQuery };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-querybuilder/core",
-  "version": "8.9.1",
+  "version": "8.10.0",
   "description": "React Query Builder component for constructing queries and filters, with utilities for executing them in various database and evaluation contexts",
   "publishConfig": {
     "access": "public"
@@ -21,36 +21,84 @@
     },
     "./dist/*": "./dist/*",
     "./formatQuery": {
-      "types": "./dist/formatQuery.d.ts",
-      "default": "./dist/formatQuery.js"
+      "import": {
+        "types": "./dist/formatQuery.d.mts",
+        "import": "./dist/formatQuery.mjs"
+      },
+      "require": {
+        "types": "./dist/formatQuery.d.ts",
+        "default": "./dist/formatQuery.js"
+      }
     },
     "./parseCEL": {
-      "types": "./dist/parseCEL.d.ts",
-      "default": "./dist/parseCEL.js"
+      "import": {
+        "types": "./dist/parseCEL.d.mts",
+        "import": "./dist/parseCEL.mjs"
+      },
+      "require": {
+        "types": "./dist/parseCEL.d.ts",
+        "default": "./dist/parseCEL.js"
+      }
     },
     "./parseJSONata": {
-      "types": "./dist/parseJSONata.d.ts",
-      "default": "./dist/parseJSONata.js"
+      "import": {
+        "types": "./dist/parseJSONata.d.mts",
+        "import": "./dist/parseJSONata.mjs"
+      },
+      "require": {
+        "types": "./dist/parseJSONata.d.ts",
+        "default": "./dist/parseJSONata.js"
+      }
     },
     "./parseJsonLogic": {
-      "types": "./dist/parseJsonLogic.d.ts",
-      "default": "./dist/parseJsonLogic.js"
+      "import": {
+        "types": "./dist/parseJsonLogic.d.mts",
+        "import": "./dist/parseJsonLogic.mjs"
+      },
+      "require": {
+        "types": "./dist/parseJsonLogic.d.ts",
+        "default": "./dist/parseJsonLogic.js"
+      }
     },
     "./parseMongoDB": {
-      "types": "./dist/parseMongoDB.d.ts",
-      "default": "./dist/parseMongoDB.js"
+      "import": {
+        "types": "./dist/parseMongoDB.d.mts",
+        "import": "./dist/parseMongoDB.mjs"
+      },
+      "require": {
+        "types": "./dist/parseMongoDB.d.ts",
+        "default": "./dist/parseMongoDB.js"
+      }
     },
     "./parseSpEL": {
-      "types": "./dist/parseSpEL.d.ts",
-      "default": "./dist/parseSpEL.js"
+      "import": {
+        "types": "./dist/parseSpEL.d.mts",
+        "import": "./dist/parseSpEL.mjs"
+      },
+      "require": {
+        "types": "./dist/parseSpEL.d.ts",
+        "default": "./dist/parseSpEL.js"
+      }
     },
     "./parseSQL": {
-      "types": "./dist/parseSQL.d.ts",
-      "default": "./dist/parseSQL.js"
+      "import": {
+        "types": "./dist/parseSQL.d.mts",
+        "import": "./dist/parseSQL.mjs"
+      },
+      "require": {
+        "types": "./dist/parseSQL.d.ts",
+        "default": "./dist/parseSQL.js"
+      }
     },
     "./transformQuery": {
-      "types": "./dist/transformQuery.d.ts",
-      "default": "./dist/transformQuery.js"
+      "import": {
+        "types": "./dist/transformQuery.d.mts",
+        "import": "./dist/transformQuery.mjs"
+      },
+      "require": {
+        "types": "./dist/transformQuery.d.ts",
+        "default": "./dist/transformQuery.js"
+      }
     }
   },
   "react-native": "dist/react-querybuilder_core.mjs",
@@ -96,24 +144,26 @@
     "@babel/core": "^7.28.4",
     "@babel/preset-env": "^7.28.3",
     "@babel/preset-typescript": "^7.27.1",
-    "@electric-sql/pglite": "^0.3.8",
+    "@electric-sql/pglite": "^0.3.10",
     "@types/json-logic-js": "^2.0.8",
-    "@types/node": "^24.5.2",
+    "@types/node": "^24.7.1",
     "babel-plugin-istanbul": "^7.0.1",
-    "drizzle-orm": "^0.44.5",
+    "drizzle-orm": "^0.44.6",
     "json-logic-js": "^2.0.5",
     "jsonata": "^2.1.0",
-    "mongodb-memory-server-core": "^10.2.1",
-    "mongoose": "^8.18.1",
+    "mongodb-memory-server-core": "^10.2.3",
+    "mongoose": "^8.19.1",
     "pglite-prisma-adapter": "^0.6.1",
-    "prisma": "~6.14.0",
+    "prisma": "~6.17.0",
     "query-string": "^9.3.1",
     "regenerator-runtime": "^0.14.1",
-    "rollup-plugin-visualizer": "^6.0.3",
-    "sass": "^1.92.1",
+    "rollup-plugin-visualizer": "^6.0.4",
+    "sass": "^1.93.2",
     "sequelize": "^6.37.7",
-    "spel2js": "^0.2.8",
-    "typescript": "^5.9.2"
+    "spel2js": "^0.2.9",
+    "type-fest": "^4.41.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.1.9"
   },
   "dependencies": {
     "immer": "^10.1.3",
@@ -143,5 +193,5 @@
     "typecheck": "tsc --noEmit",
     "typecheck:watch": "tsc --noEmit --watch"
   },
-  "gitHead": "d4d46ff2a6afb1623f3cb8f666c8b2e02ee7cd2f"
+  "gitHead": "fc383fac6b7deefae34f004c6fe60b924ddd3b20"
 }