@react-querybuilder/datetime 8.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Jake Boone and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,71 @@
+## @react-querybuilder/datetime
+
+> [!NOTE]
+>
+> This package is experimental and its API is not guaranteed to be stable.
+
+Augments [react-querybuilder](https://npmjs.com/package/react-querybuilder) with enhanced date/time functionality.
+
+To see this in action, check out the [`react-querybuilder` demo](https://react-querybuilder.js.org/demo#datetime=true) with the "date/time" option enabled.
+
+**[Full documentation](https://react-querybuilder.js.org/docs/datetime)**
+
+<!-- ![Screenshot](../../_assets/screenshot.png) -->
+
+## Installation
+
+```bash
+npm i react-querybuilder @react-querybuilder/datetime
+# OR yarn add / pnpm add / bun add
+```
+
+## Usage
+
+<!--
+To enable the date and time functionality of a query builder, nest the `QueryBuilder` element under `QueryBuilderDateTime`.
+
+```tsx
+import { QueryBuilderDateTime } from '@react-querybuilder/datetime';
+import { useState } from 'react';
+import { QueryBuilder, RuleGroupType } from 'react-querybuilder';
+
+const fields = [
+  { name: 'firstName', label: 'First Name' },
+  { name: 'lastName', label: 'Last Name' },
+];
+
+const App = () => {
+  const [query, setQuery] = useState<RuleGroupType>({ combinator: 'and', rules: [] });
+
+  return (
+    <QueryBuilderDateTime>
+      <QueryBuilder fields={fields} defaultQuery={query} onQueryChange={setQuery} />
+    </QueryBuilderDateTime>
+  );
+};
+```
+-->
+
+To add date/time functionality to `formatQuery`, import a rule processor from `@react-querybuilder/datetime/dayjs`, `@react-querybuilder/datetime/date-fns`, or `@react-querybuilder/datetime/luxon`—depending on which library you wish to use or are already using—and pass it to the `ruleProcessor` option.
+
+```ts
+import { formatQuery } from 'react-querybuilder';
+import {
+  datetimeRuleProcessorMongoDBQuery,
+  datetimeRuleProcessorSQL,
+} from '@react-querybuilder/datetime/dayjs';
+
+// SQL
+formatQuery(query, { preset: 'postgresql', fields, ruleProcessor: datetimeRuleProcessorSQL });
+
+// MongoDB
+formatQuery(query, {
+  format: 'mongodb_query',
+  fields,
+  ruleProcessor: datetimeRuleProcessorMongoDBQuery,
+});
+```
+
+The date/time rule processors will fallback to using the default rule processors if the rule's field configuration does not have a `datatype` value of "date", "datetime", "datetimeoffset", or "timestamp", or if the `operator` is specific to string comparisons ("contains", "beginsWith", "endsWith", etc.). You can provide a custom `isDateField` function to override this behavior through the `context` option.
+
+<!-- ## Notes -->

package/dist/chunk-6RML23AL.mjs

@@ -0,0 +1,536 @@
+// src/getDatetimeJsonLogicOperations.ts
+var getDatetimeJsonLogicOperations = function getDatetimeJsonLogicOperations2(_ref) {
+  var isAfter = _ref.isAfter, isBefore = _ref.isBefore, isSame = _ref.isSame;
+  return { dateAfter: function dateAfter(a, b) {
+    return isAfter(a, b);
+  }, dateBefore: function dateBefore(a, b) {
+    return isBefore(a, b);
+  }, dateBetween: function dateBetween(a, b, c) {
+    return isSame(b, a) || isSame(b, c) || isAfter(b, a) && isBefore(b, c) || isAfter(b, c) && isBefore(b, a);
+  }, dateNotBetween: function dateNotBetween(a, b, c) {
+    return !isSame(b, a) && !isSame(b, c) && (isBefore(a, c) && (isBefore(b, a) || isAfter(b, c)) || isAfter(a, c) && (isBefore(b, c) || isAfter(b, a)));
+  }, dateIn: function dateIn(a, b) {
+    return b.some(function(v) {
+      return isSame(a, v);
+    });
+  }, dateNotIn: function dateNotIn(a, b) {
+    return b.every(function(v) {
+      return !isSame(a, v);
+    });
+  }, dateNotOn: function dateNotOn(a, b) {
+    return !isSame(a, b);
+  }, dateOn: function dateOn(a, b) {
+    return isSame(a, b);
+  }, dateOnOrAfter: function dateOnOrAfter(a, b) {
+    return isAfter(a, b) || isSame(a, b);
+  }, dateOnOrBefore: function dateOnOrBefore(a, b) {
+    return isBefore(a, b) || isSame(a, b);
+  } };
+};
+
+// src/getDatetimeRuleProcessorCEL.ts
+import { defaultRuleProcessorCEL, toArray } from "react-querybuilder";
+
+// src/utils.ts
+function _typeof(o) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof(o);
+}
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e, n, i, u, a = [], f = true, o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = false;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
+    } catch (r2) {
+      o = true, n = r2;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+var isISOStringDateOnly = function isISOStringDateOnly2(date) {
+  return typeof date === "string" && /^\d{4}-\d{2}-\d{2}$/.test(date);
+};
+var defaultIsDateField = function defaultIsDateField2() {
+  var _opts$fieldData;
+  for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
+    _ref[_key] = arguments[_key];
+  }
+  var rule = _ref[0], opts = _ref[1];
+  return rule.operator !== "contains" && rule.operator !== "beginsWith" && rule.operator !== "endsWith" && rule.operator !== "doesNotContain" && rule.operator !== "doesNotBeginWith" && rule.operator !== "doesNotEndWith" && rule.operator !== "null" && rule.operator !== "notNull" && /^(?:date|datetime|datetimeoffset|timestamp)\b/i.test(opts === null || opts === void 0 || (_opts$fieldData = opts.fieldData) === null || _opts$fieldData === void 0 ? void 0 : _opts$fieldData.datatype);
+};
+var processIsDateField = function processIsDateField2(isDateField) {
+  for (var _len2 = arguments.length, _ref2 = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+    _ref2[_key2 - 1] = arguments[_key2];
+  }
+  var rule = _ref2[0], opts = _ref2[1];
+  if (typeof isDateField === "boolean") {
+    return isDateField;
+  }
+  if (typeof isDateField === "function") {
+    return isDateField(rule, opts);
+  }
+  if (Array.isArray(isDateField)) {
+    return isDateField.some(function(condition) {
+      return Object.entries(condition).every(function(_ref3) {
+        var _opts$fieldData2;
+        var _ref4 = _slicedToArray(_ref3, 2), key = _ref4[0], value = _ref4[1];
+        return (opts === null || opts === void 0 || (_opts$fieldData2 = opts.fieldData) === null || _opts$fieldData2 === void 0 ? void 0 : _opts$fieldData2[key]) === value;
+      });
+    });
+  }
+  if (_typeof(isDateField) === "object") {
+    return Object.entries(isDateField).every(function(_ref5) {
+      var _opts$fieldData3;
+      var _ref6 = _slicedToArray(_ref5, 2), key = _ref6[0], value = _ref6[1];
+      return (opts === null || opts === void 0 || (_opts$fieldData3 = opts.fieldData) === null || _opts$fieldData3 === void 0 ? void 0 : _opts$fieldData3[key]) === value;
+    });
+  }
+  return defaultIsDateField(rule, opts);
+};
+
+// src/getDatetimeRuleProcessorCEL.ts
+function _slicedToArray2(r, e) {
+  return _arrayWithHoles2(r) || _iterableToArrayLimit2(r, e) || _unsupportedIterableToArray2(r, e) || _nonIterableRest2();
+}
+function _nonIterableRest2() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _unsupportedIterableToArray2(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray2(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray2(r, a) : void 0;
+  }
+}
+function _arrayLikeToArray2(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _iterableToArrayLimit2(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e, n, i, u, a = [], f = true, o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = false;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
+    } catch (r2) {
+      o = true, n = r2;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _arrayWithHoles2(r) {
+  if (Array.isArray(r)) return r;
+}
+var shouldNegate = function shouldNegate2(op) {
+  return /^(does)?not/i.test(op);
+};
+var getDatetimeRuleProcessorCEL = function getDatetimeRuleProcessorCEL2(apiFns) {
+  return function(rule, options) {
+    var opts = options !== null && options !== void 0 ? options : (
+      /* istanbul ignore next */
+      {}
+    );
+    var _opts$context = opts.context, context = _opts$context === void 0 ? {} : _opts$context;
+    if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) {
+      return defaultRuleProcessorCEL(rule, opts);
+    }
+    var ts = function ts2(d) {
+      return 'timestamp("'.concat(apiFns.toISOString(d), '")');
+    };
+    var operatorTL = rule.operator.replace(/^=$/, "==").toLowerCase();
+    switch (operatorTL) {
+      case "<":
+      case "<=":
+      case "==":
+      case "!=":
+      case ">":
+      case ">=":
+        return "".concat(rule.field, " ").concat(operatorTL, " ").concat(ts(rule.value));
+    }
+    var valueAsArray = toArray(rule.value, { retainEmptyStrings: false });
+    var valueAsDateArray = valueAsArray.map(function(v) {
+      return apiFns.toDate(v);
+    }).filter(function(dateVal) {
+      return apiFns.isValid(dateVal);
+    });
+    switch (operatorTL) {
+      case "in":
+      case "notin": {
+        if (valueAsDateArray.length === 0) return "";
+        var _ref = shouldNegate(operatorTL) ? ["!(", ")"] : ["", ""], _ref2 = _slicedToArray2(_ref, 2), prefix = _ref2[0], suffix = _ref2[1];
+        return "".concat(prefix).concat(rule.field, " in [").concat(valueAsDateArray.map(function(val) {
+          return ts(val);
+        }).join(", "), "]").concat(suffix);
+      }
+      case "between":
+      case "notbetween": {
+        if (valueAsDateArray.length < 2) return "";
+        var _valueAsDateArray = _slicedToArray2(valueAsDateArray, 2), first = _valueAsDateArray[0], second = _valueAsDateArray[1];
+        var _ref3 = apiFns.isBefore(first, second) ? [first, second] : [second, first], _ref4 = _slicedToArray2(_ref3, 2), firstDate = _ref4[0], secondDate = _ref4[1];
+        return operatorTL === "between" ? "(".concat(rule.field, " >= ").concat(ts(firstDate), " && ").concat(rule.field, " <= ").concat(ts(secondDate), ")") : "(".concat(rule.field, " < ").concat(ts(firstDate), " || ").concat(rule.field, " > ").concat(ts(secondDate), ")");
+      }
+    }
+    return defaultRuleProcessorCEL(rule, opts);
+  };
+};
+
+// src/getDatetimeRuleProcessorMongoDBQuery.ts
+import { defaultRuleProcessorMongoDBQuery, mongoOperators, toArray as toArray2 } from "react-querybuilder";
+function _typeof2(o) {
+  "@babel/helpers - typeof";
+  return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof2(o);
+}
+function _slicedToArray3(r, e) {
+  return _arrayWithHoles3(r) || _iterableToArrayLimit3(r, e) || _unsupportedIterableToArray3(r, e) || _nonIterableRest3();
+}
+function _nonIterableRest3() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _unsupportedIterableToArray3(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray3(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray3(r, a) : void 0;
+  }
+}
+function _arrayLikeToArray3(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _iterableToArrayLimit3(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e, n, i, u, a = [], f = true, o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = false;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
+    } catch (r2) {
+      o = true, n = r2;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _arrayWithHoles3(r) {
+  if (Array.isArray(r)) return r;
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == _typeof2(i) ? i : i + "";
+}
+function _toPrimitive(t, r) {
+  if ("object" != _typeof2(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != _typeof2(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+var getDatetimeRuleProcessorMongoDBQuery = function getDatetimeRuleProcessorMongoDBQuery2(apiFns) {
+  return function(rule, options) {
+    var _opts$context;
+    var opts = options !== null && options !== void 0 ? options : (
+      /* istanbul ignore next */
+      {}
+    );
+    var field = rule.field, operator = rule.operator, value = rule.value, valueSource = rule.valueSource;
+    if (valueSource === "field" || !processIsDateField((_opts$context = opts.context) === null || _opts$context === void 0 ? void 0 : _opts$context.isDateField, rule, opts)) {
+      return defaultRuleProcessorMongoDBQuery(rule, opts);
+    }
+    if (operator === "=") {
+      return _defineProperty({}, field, apiFns.toDate(value));
+    }
+    switch (operator) {
+      case "<":
+      case "<=":
+      case "!=":
+      case ">":
+      case ">=":
+        return _defineProperty({}, field, _defineProperty({}, mongoOperators[operator], apiFns.toDate(value)));
+    }
+    var valueAsArray = toArray2(rule.value, { retainEmptyStrings: false });
+    var valueAsDateArray = valueAsArray.map(function(v) {
+      return apiFns.toDate(v);
+    }).filter(function(dateVal) {
+      return apiFns.isValid(dateVal);
+    });
+    switch (operator) {
+      case "in":
+      case "notIn":
+        return _defineProperty({}, field, _defineProperty({}, mongoOperators[operator], valueAsDateArray));
+      case "between":
+      case "notBetween": {
+        if (valueAsDateArray.length < 2) return "";
+        var _valueAsDateArray = _slicedToArray3(valueAsDateArray, 2), first = _valueAsDateArray[0], second = _valueAsDateArray[1];
+        var orderedArray = apiFns.isBefore(first, second) ? [first, second] : [second, first];
+        return operator === "between" ? _defineProperty({}, field, { $gte: orderedArray[0], $lte: orderedArray[1] }) : { $or: [_defineProperty({}, field, { $lt: orderedArray[0] }), _defineProperty({}, field, { $gt: orderedArray[1] })] };
+      }
+    }
+    return defaultRuleProcessorMongoDBQuery(rule, opts);
+  };
+};
+
+// src/getDatetimeRuleProcessorSQL.ts
+import { defaultRuleProcessorSQL, defaultValueProcessorByRule, getQuotedFieldName, mapSQLOperator, toArray as toArray3 } from "react-querybuilder";
+function _typeof3(o) {
+  "@babel/helpers - typeof";
+  return _typeof3 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof3(o);
+}
+function _slicedToArray4(r, e) {
+  return _arrayWithHoles4(r) || _iterableToArrayLimit4(r, e) || _unsupportedIterableToArray4(r, e) || _nonIterableRest4();
+}
+function _nonIterableRest4() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _unsupportedIterableToArray4(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray4(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray4(r, a) : void 0;
+  }
+}
+function _arrayLikeToArray4(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _iterableToArrayLimit4(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e, n, i, u, a = [], f = true, o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = false;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
+    } catch (r2) {
+      o = true, n = r2;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _arrayWithHoles4(r) {
+  if (Array.isArray(r)) return r;
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+      _defineProperty2(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+function _defineProperty2(e, r, t) {
+  return (r = _toPropertyKey2(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
+}
+function _toPropertyKey2(t) {
+  var i = _toPrimitive2(t, "string");
+  return "symbol" == _typeof3(i) ? i : i + "";
+}
+function _toPrimitive2(t, r) {
+  if ("object" != _typeof3(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != _typeof3(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+var getDatetimeValueProcessorANSI = function getDatetimeValueProcessorANSI2(_ref) {
+  var toISOStringDateOnly = _ref.toISOStringDateOnly, toISOString = _ref.toISOString;
+  return function(rule, opts) {
+    var _opts$context;
+    if (isISOStringDateOnly(opts === null || opts === void 0 || (_opts$context = opts.context) === null || _opts$context === void 0 ? void 0 : _opts$context.originalValue)) {
+      return defaultValueProcessorByRule(_objectSpread(_objectSpread({}, rule), {}, { value: toISOStringDateOnly(rule.value) }), opts);
+    }
+    return defaultValueProcessorByRule(_objectSpread(_objectSpread({}, rule), {}, { value: toISOString(rule.value) }), opts);
+  };
+};
+var getDatetimeValueProcessorMSSQL = function getDatetimeValueProcessorMSSQL2(_ref2) {
+  var toISOStringDateOnly = _ref2.toISOStringDateOnly, toISOString = _ref2.toISOString;
+  return function(rule, opts) {
+    var _opts$fieldData;
+    var datatype = /^(?:small)?datetime/i.test(opts === null || opts === void 0 || (_opts$fieldData = opts.fieldData) === null || _opts$fieldData === void 0 ? void 0 : _opts$fieldData.datatype) ? "datetimeoffset" : "date";
+    var value = datatype === "datetimeoffset" ? toISOString(rule.value) : toISOStringDateOnly(rule.value);
+    return defaultValueProcessorByRule(_objectSpread(_objectSpread({}, rule), {}, { value }), _objectSpread(_objectSpread({}, opts), {}, { wrapValueWith: ["cast(", " as ".concat(datatype, ")")] }));
+  };
+};
+var getDatetimeValueProcessorMySQL = function getDatetimeValueProcessorMySQL2(_ref3) {
+  var toISOStringDateOnly = _ref3.toISOStringDateOnly, toISOString = _ref3.toISOString;
+  return function(rule, opts) {
+    var _opts$fieldData2;
+    var datatype = /^(?:datetime|timestamp)/i.test(opts === null || opts === void 0 || (_opts$fieldData2 = opts.fieldData) === null || _opts$fieldData2 === void 0 ? void 0 : _opts$fieldData2.datatype) ? "datetime" : "date";
+    var value = datatype === "datetime" ? toISOString(rule.value) : toISOStringDateOnly(rule.value);
+    return defaultValueProcessorByRule(_objectSpread(_objectSpread({}, rule), {}, { value }), _objectSpread(_objectSpread({}, opts), {}, { wrapValueWith: ["cast(", " as ".concat(datatype, ")")] }));
+  };
+};
+var getDatetimeValueProcessorOracle = function getDatetimeValueProcessorOracle2(_ref4) {
+  var toISOStringDateOnly = _ref4.toISOStringDateOnly, toISOString = _ref4.toISOString;
+  return function(rule, opts) {
+    var _opts$fieldData3;
+    var datatype = /^timestamp/i.test(opts === null || opts === void 0 || (_opts$fieldData3 = opts.fieldData) === null || _opts$fieldData3 === void 0 ? void 0 : _opts$fieldData3.datatype) ? "timestamp" : "date";
+    var value = datatype === "timestamp" ? toISOString(rule.value).replaceAll("T", " ").replace("Z", " UTC") : toISOStringDateOnly(rule.value);
+    return defaultValueProcessorByRule(_objectSpread(_objectSpread({}, rule), {}, { value }), _objectSpread(_objectSpread({}, opts), {}, { wrapValueWith: [datatype, ""] }));
+  };
+};
+var getDatetimeValueProcessorPostgreSQL = function getDatetimeValueProcessorPostgreSQL2(_ref5) {
+  var toISOStringDateOnly = _ref5.toISOStringDateOnly, toISOString = _ref5.toISOString;
+  return function(rule, opts) {
+    var _opts$fieldData4;
+    var datatype = /^timestamp/i.test(opts === null || opts === void 0 || (_opts$fieldData4 = opts.fieldData) === null || _opts$fieldData4 === void 0 ? void 0 : _opts$fieldData4.datatype) ? "timestamp" : "date";
+    var value = datatype === "timestamp" ? toISOString(rule.value) : toISOStringDateOnly(rule.value);
+    return defaultValueProcessorByRule(_objectSpread(_objectSpread({}, rule), {}, { value }), _objectSpread(_objectSpread({}, opts), {}, { wrapValueWith: [datatype, ""] }));
+  };
+};
+var presetToValueProcessorMap = { ansi: getDatetimeValueProcessorANSI, mssql: getDatetimeValueProcessorMSSQL, mysql: getDatetimeValueProcessorMySQL, oracle: getDatetimeValueProcessorOracle, postgresql: getDatetimeValueProcessorPostgreSQL, sqlite: getDatetimeValueProcessorANSI };
+var getDatetimeRuleProcessorSQL = function getDatetimeRuleProcessorSQL2(apiFns) {
+  return function(rule, options) {
+    var opts = options !== null && options !== void 0 ? options : (
+      /* istanbul ignore next */
+      {}
+    );
+    var operator = mapSQLOperator(rule.operator);
+    var operatorLowerCase = operator.toLowerCase();
+    var _opts$quoteFieldNames = opts.quoteFieldNamesWith, quoteFieldNamesWith = _opts$quoteFieldNames === void 0 ? ["", ""] : _opts$quoteFieldNames, _opts$fieldIdentifier = opts.fieldIdentifierSeparator, fieldIdentifierSeparator = _opts$fieldIdentifier === void 0 ? "" : _opts$fieldIdentifier, _opts$context2 = opts.context, context = _opts$context2 === void 0 ? {} : _opts$context2;
+    var finalValue = "";
+    if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) {
+      return defaultRuleProcessorSQL(rule, opts);
+    }
+    var valueProcessor = presetToValueProcessorMap[opts.preset](apiFns);
+    var valueAsArray = toArray3(rule.value, { retainEmptyStrings: false });
+    var valueAsDateArray = valueAsArray.map(function(v) {
+      return [v, apiFns.toDate(v)];
+    }).filter(function(v) {
+      return apiFns.isValid(v[1]);
+    });
+    switch (operatorLowerCase) {
+      case "in":
+      case "not in":
+        {
+          if (valueAsDateArray.length === 0) return "";
+          finalValue = "(".concat(valueAsDateArray.map(function(value2) {
+            return valueProcessor({ field: rule.field, operator: "=", value: value2[1] }, _objectSpread(_objectSpread({}, opts), {}, { context: { originalValue: value2[0] } }));
+          }).join(", "), ")");
+        }
+        break;
+      case "between":
+      case "not between":
+        {
+          if (valueAsDateArray.length < 2) return "";
+          var _valueAsDateArray = _slicedToArray4(valueAsDateArray, 2), first = _valueAsDateArray[0], second = _valueAsDateArray[1];
+          var orderedArray = apiFns.isBefore(first[1], second[1]) ? [first, second] : [second, first];
+          finalValue = orderedArray.map(function(_ref6) {
+            var _ref7 = _slicedToArray4(_ref6, 2), originalValue2 = _ref7[0], value2 = _ref7[1];
+            return valueProcessor({ field: rule.field, operator: "=", value: value2 }, _objectSpread(_objectSpread({}, opts), {}, { context: { originalValue: originalValue2 } }));
+          }).join(" and ");
+        }
+        break;
+      default: {
+        var _valueAsDateArray$ = _slicedToArray4(valueAsDateArray[0], 2), originalValue = _valueAsDateArray$[0], value = _valueAsDateArray$[1];
+        finalValue = valueProcessor({ field: rule.field, operator: "=", value }, _objectSpread(_objectSpread({}, opts), {}, { context: { originalValue } }));
+      }
+    }
+    return "".concat(getQuotedFieldName(rule.field, { quoteFieldNamesWith, fieldIdentifierSeparator }), " ").concat(operator, " ").concat(finalValue).trim();
+  };
+};
+
+export {
+  isISOStringDateOnly,
+  processIsDateField,
+  getDatetimeJsonLogicOperations,
+  getDatetimeRuleProcessorCEL,
+  getDatetimeRuleProcessorMongoDBQuery,
+  getDatetimeValueProcessorANSI,
+  getDatetimeValueProcessorMSSQL,
+  getDatetimeValueProcessorMySQL,
+  getDatetimeValueProcessorOracle,
+  getDatetimeValueProcessorPostgreSQL,
+  getDatetimeRuleProcessorSQL
+};
+//# sourceMappingURL=chunk-6RML23AL.mjs.map