@choice-ui/react 1.3.10

package/dist/cjs/components/conditions/src/utils/operator-utils.cjs

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require$$0 = require("react/jsx-runtime");
+const index = require("../../../select/dist/index.cjs");
+const arrayLengthInput = require("../components/condition-items/array-length-input.cjs");
+const booleanInput = require("../components/condition-items/boolean-input.cjs");
+const dateInput = require("../components/condition-items/date-input.cjs");
+const multiSelectInput = require("../components/condition-items/multi-select-input.cjs");
+const numberInput = require("../components/condition-items/number-input.cjs");
+const regexInput = require("../components/condition-items/regex-input.cjs");
+const selectInput = require("../components/condition-items/select-input.cjs");
+const tagInput = require("../components/condition-items/tag-input.cjs");
+const textInput = require("../components/condition-items/text-input.cjs");
+const userInput = require("../components/condition-items/user-input.cjs");
+const types = require("../types.cjs");
+const constants = require("./constants.cjs");
+function getOperatorGroups(availableOperators) {
+  const groups = [
+    {
+      label: "General",
+      operators: [
+        types.ComparisonOperator.Equals,
+        types.ComparisonOperator.NotEquals,
+        types.ComparisonOperator.Exists,
+        types.ComparisonOperator.DoesNotExist
+      ]
+    },
+    {
+      label: "Text",
+      operators: [
+        types.ComparisonOperator.Contains,
+        types.ComparisonOperator.NotContains,
+        types.ComparisonOperator.StartsWith,
+        types.ComparisonOperator.EndsWith,
+        types.ComparisonOperator.MatchesRegex,
+        types.ComparisonOperator.DoesNotMatchRegex
+      ]
+    },
+    {
+      label: "Numbers & Comparison",
+      operators: [
+        types.ComparisonOperator.GreaterThan,
+        types.ComparisonOperator.GreaterThanOrEqual,
+        types.ComparisonOperator.LessThan,
+        types.ComparisonOperator.LessThanOrEqual,
+        types.ComparisonOperator.Between
+      ]
+    },
+    {
+      label: "Arrays & Collections",
+      operators: [
+        types.ComparisonOperator.In,
+        types.ComparisonOperator.NotIn,
+        types.ComparisonOperator.IsEmpty,
+        types.ComparisonOperator.IsNotEmpty,
+        types.ComparisonOperator.LengthEquals,
+        types.ComparisonOperator.LengthGreaterThan,
+        types.ComparisonOperator.LengthLessThan,
+        types.ComparisonOperator.LengthGreaterThanOrEqual,
+        types.ComparisonOperator.LengthLessThanOrEqual
+      ]
+    },
+    {
+      label: "Dates",
+      operators: [
+        types.ComparisonOperator.IsAfter,
+        types.ComparisonOperator.IsBefore,
+        types.ComparisonOperator.IsWithin,
+        types.ComparisonOperator.IsToday,
+        types.ComparisonOperator.IsYesterday,
+        types.ComparisonOperator.IsTomorrow,
+        types.ComparisonOperator.IsThisWeek,
+        types.ComparisonOperator.IsLastWeek,
+        types.ComparisonOperator.IsNextWeek,
+        types.ComparisonOperator.IsThisMonth,
+        types.ComparisonOperator.IsLastMonth,
+        types.ComparisonOperator.IsNextMonth
+      ]
+    },
+    {
+      label: "Boolean",
+      operators: [types.ComparisonOperator.IsTrue, types.ComparisonOperator.IsFalse]
+    }
+  ];
+  return groups.map((group) => ({
+    ...group,
+    operators: group.operators.filter((op) => availableOperators.includes(op))
+  })).filter((group) => group.operators.length > 0);
+}
+function renderGroupedOperators(operatorGroups) {
+  const elements = [];
+  operatorGroups.forEach((group, groupIndex) => {
+    if (groupIndex > 0) {
+      elements.push(/* @__PURE__ */ require$$0.jsx(index.Select.Divider, {}, `divider-${groupIndex}`));
+    }
+    if (operatorGroups.length > 1) {
+      elements.push(/* @__PURE__ */ require$$0.jsx(index.Select.Label, { children: group.label }, `label-${groupIndex}`));
+    }
+    group.operators.forEach((operator) => {
+      const config = constants.OPERATOR_CONFIGS[operator];
+      elements.push(
+        /* @__PURE__ */ require$$0.jsx(
+          index.Select.Item,
+          {
+            value: operator,
+            children: /* @__PURE__ */ require$$0.jsx(index.Select.Value, { children: (config == null ? void 0 : config.label) || operator })
+          },
+          operator
+        )
+      );
+    });
+  });
+  return elements;
+}
+function renderValueInput(props) {
+  const { condition, field, disabled, onChange } = props;
+  const commonProps = {
+    condition,
+    field,
+    disabled,
+    onChange
+  };
+  if (condition.operator === types.ComparisonOperator.MatchesRegex || condition.operator === types.ComparisonOperator.DoesNotMatchRegex) {
+    return /* @__PURE__ */ require$$0.jsx(regexInput.RegexInput, { ...commonProps });
+  }
+  if (condition.operator === types.ComparisonOperator.LengthEquals || condition.operator === types.ComparisonOperator.LengthGreaterThan || condition.operator === types.ComparisonOperator.LengthLessThan || condition.operator === types.ComparisonOperator.LengthGreaterThanOrEqual || condition.operator === types.ComparisonOperator.LengthLessThanOrEqual) {
+    return /* @__PURE__ */ require$$0.jsx(arrayLengthInput.ArrayLengthInput, { ...commonProps });
+  }
+  switch (field.type) {
+    case types.ConditionsFieldType.Text:
+      return /* @__PURE__ */ require$$0.jsx(textInput.TextInput, { ...commonProps });
+    case types.ConditionsFieldType.Number:
+      return /* @__PURE__ */ require$$0.jsx(numberInput.NumberInput, { ...commonProps });
+    case types.ConditionsFieldType.Boolean:
+      return /* @__PURE__ */ require$$0.jsx(booleanInput.BooleanInput, { ...commonProps });
+    case types.ConditionsFieldType.Date:
+    case types.ConditionsFieldType.DateTime:
+      return /* @__PURE__ */ require$$0.jsx(dateInput.ConditionDateInput, { ...commonProps });
+    case types.ConditionsFieldType.Select:
+      return /* @__PURE__ */ require$$0.jsx(selectInput.SelectInput, { ...commonProps });
+    case types.ConditionsFieldType.MultiSelect:
+      return /* @__PURE__ */ require$$0.jsx(multiSelectInput.MultiSelectInput, { ...commonProps });
+    case types.ConditionsFieldType.User:
+      return /* @__PURE__ */ require$$0.jsx(userInput.UserInput, { ...commonProps });
+    case types.ConditionsFieldType.Tag:
+      return /* @__PURE__ */ require$$0.jsx(tagInput.TagInput, { ...commonProps });
+    default:
+      return /* @__PURE__ */ require$$0.jsx(textInput.TextInput, { ...commonProps });
+  }
+}
+function renderSecondValueInput(props) {
+  const { condition, field, disabled, onChange, onSecondValueChange } = props;
+  if (!onSecondValueChange) {
+    return null;
+  }
+  const commonProps = {
+    condition,
+    field,
+    disabled,
+    onChange,
+    onSecondValueChange
+  };
+  switch (field.type) {
+    case types.ConditionsFieldType.Number:
+      return /* @__PURE__ */ require$$0.jsx(numberInput.NumberRangeInput, { ...commonProps });
+    case types.ConditionsFieldType.DateTime:
+      return /* @__PURE__ */ require$$0.jsx(dateInput.ConditionDateRangeInput, { ...commonProps });
+    default:
+      return null;
+  }
+}
+exports.getOperatorGroups = getOperatorGroups;
+exports.renderGroupedOperators = renderGroupedOperators;
+exports.renderSecondValueInput = renderSecondValueInput;
+exports.renderValueInput = renderValueInput;

package/dist/cjs/components/conditions/src/utils/utilities.cjs

@@ -0,0 +1,351 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const nanoid = require("nanoid");
+const constants = require("./constants.cjs");
+function generateId(prefix) {
+  return `${constants.ID_PREFIXES[prefix]}${nanoid.nanoid()}`;
+}
+function generateConditionId() {
+  return generateId("condition");
+}
+function generateGroupId() {
+  return generateId("group");
+}
+function generateGroupName(existingGroups = []) {
+  let maxIndex = 0;
+  function findMaxIndex(groups) {
+    groups.forEach((group) => {
+      if (group.name) {
+        const match = group.name.match(/^Group (\d+)$/i);
+        if (match) {
+          const index = parseInt(match[1], 10);
+          if (index > maxIndex) {
+            maxIndex = index;
+          }
+        }
+      }
+      const nestedGroups = group.conditions.filter(
+        (item) => "logicalOperator" in item
+      );
+      if (nestedGroups.length > 0) {
+        findMaxIndex(nestedGroups);
+      }
+    });
+  }
+  findMaxIndex(existingGroups);
+  return `Group ${maxIndex + 1}`;
+}
+function generateRootId() {
+  return generateId("root");
+}
+function createCondition(fieldKey, operator, value) {
+  return {
+    id: generateConditionId(),
+    fieldKey: fieldKey || "",
+    operator: operator || constants.DEFAULT_COMPARISON_OPERATOR,
+    value: value || null
+  };
+}
+function createConditionGroup(logicalOperator = constants.DEFAULT_LOGICAL_OPERATOR, conditions = [], name) {
+  return {
+    id: generateGroupId(),
+    logicalOperator,
+    conditions,
+    name
+  };
+}
+function createConditionsRoot(groups = []) {
+  return {
+    id: generateRootId(),
+    groups
+  };
+}
+function createEmptyConditions() {
+  return createConditionsRoot([
+    createConditionGroup(constants.DEFAULT_LOGICAL_OPERATOR, [createCondition()], "Group 1")
+  ]);
+}
+function findCondition(root, conditionId) {
+  for (const group of root.groups) {
+    const result = findConditionInGroup(group, conditionId);
+    if (result) return result;
+  }
+  return null;
+}
+function findConditionInGroup(group, conditionId) {
+  for (const item of group.conditions) {
+    if ("fieldKey" in item && item.id === conditionId) {
+      return { condition: item, parent: group };
+    }
+    if ("logicalOperator" in item) {
+      const result = findConditionInGroup(item, conditionId);
+      if (result) return result;
+    }
+  }
+  return null;
+}
+function findGroup(root, groupId) {
+  for (const group of root.groups) {
+    if (group.id === groupId) {
+      return { group, parent: root };
+    }
+    const result = findGroupInGroup(group, groupId);
+    if (result) return result;
+  }
+  return null;
+}
+function findGroupInGroup(group, groupId) {
+  for (const item of group.conditions) {
+    if ("logicalOperator" in item) {
+      if (item.id === groupId) {
+        return { group: item, parent: group };
+      }
+      const result = findGroupInGroup(item, groupId);
+      if (result) return result;
+    }
+  }
+  return null;
+}
+function getConditionPath(root, conditionId) {
+  const path = [];
+  function searchInGroup(group, currentPath) {
+    for (let i = 0; i < group.conditions.length; i++) {
+      const item = group.conditions[i];
+      const itemPath = [...currentPath, `conditions[${i}]`];
+      if ("fieldKey" in item && item.id === conditionId) {
+        path.push(...itemPath);
+        return true;
+      }
+      if ("logicalOperator" in item) {
+        if (searchInGroup(item, itemPath)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  for (let i = 0; i < root.groups.length; i++) {
+    const group = root.groups[i];
+    const groupPath = [`groups[${i}]`];
+    if (searchInGroup(group, groupPath)) {
+      path.unshift(...groupPath);
+      break;
+    }
+  }
+  return path;
+}
+function getGroupPath(root, groupId) {
+  const path = [];
+  function searchInGroup(group, currentPath) {
+    if (group.id === groupId) {
+      path.push(...currentPath);
+      return true;
+    }
+    for (let i = 0; i < group.conditions.length; i++) {
+      const item = group.conditions[i];
+      if ("logicalOperator" in item) {
+        const itemPath = [...currentPath, `conditions[${i}]`];
+        if (searchInGroup(item, itemPath)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  for (let i = 0; i < root.groups.length; i++) {
+    const group = root.groups[i];
+    const groupPath = [`groups[${i}]`];
+    if (searchInGroup(group, groupPath)) {
+      break;
+    }
+  }
+  return path;
+}
+function isOperatorValidForFieldType(fieldType, operator) {
+  var _a;
+  return ((_a = constants.FIELD_OPERATOR_MAP[fieldType]) == null ? void 0 : _a.includes(operator)) || false;
+}
+function validateCondition(condition, fields) {
+  const errors = [];
+  if (!condition.fieldKey) {
+    errors.push({
+      path: [condition.id],
+      message: "Field is required",
+      field: condition.fieldKey
+    });
+    return errors;
+  }
+  const field = fields.find((f) => f.key === condition.fieldKey);
+  if (!field) {
+    errors.push({
+      path: [condition.id],
+      message: `Field "${condition.fieldKey}" not found`,
+      field: condition.fieldKey
+    });
+    return errors;
+  }
+  if (!condition.operator) {
+    errors.push({
+      path: [condition.id],
+      message: "Operator is required",
+      operator: condition.operator
+    });
+    return errors;
+  }
+  if (!isOperatorValidForFieldType(field.type, condition.operator)) {
+    errors.push({
+      path: [condition.id],
+      message: `Operator "${condition.operator}" is not valid for field type "${field.type}"`,
+      field: condition.fieldKey,
+      operator: condition.operator
+    });
+  }
+  const operatorConfig = constants.OPERATOR_CONFIGS[condition.operator];
+  if ((operatorConfig == null ? void 0 : operatorConfig.valueRequired) && (condition.value === null || condition.value === void 0 || condition.value === "")) {
+    errors.push({
+      path: [condition.id],
+      message: "Value is required for this operator",
+      field: condition.fieldKey,
+      operator: condition.operator
+    });
+  }
+  if ((operatorConfig == null ? void 0 : operatorConfig.secondValueRequired) && (condition.secondValue === null || condition.secondValue === void 0 || condition.secondValue === "")) {
+    errors.push({
+      path: [condition.id],
+      message: "Second value is required for this operator",
+      field: condition.fieldKey,
+      operator: condition.operator
+    });
+  }
+  return errors;
+}
+function validateConditionGroup(group, fields) {
+  const errors = [];
+  if (group.conditions.length === 0) {
+    errors.push({
+      path: [group.id],
+      message: "Condition group must have at least one condition"
+    });
+  }
+  group.conditions.forEach((item, index) => {
+    if ("fieldKey" in item) {
+      const conditionErrors = validateCondition(item, fields);
+      errors.push(
+        ...conditionErrors.map((error) => ({
+          ...error,
+          path: [group.id, `conditions[${index}]`, ...error.path]
+        }))
+      );
+    } else {
+      const groupErrors = validateConditionGroup(item, fields);
+      errors.push(
+        ...groupErrors.map((error) => ({
+          ...error,
+          path: [group.id, `conditions[${index}]`, ...error.path]
+        }))
+      );
+    }
+  });
+  return errors;
+}
+function validateConditions(root, fields) {
+  const errors = [];
+  root.groups.forEach((group, index) => {
+    const groupErrors = validateConditionGroup(group, fields);
+    errors.push(
+      ...groupErrors.map((error) => ({
+        ...error,
+        path: [`groups[${index}]`, ...error.path]
+      }))
+    );
+  });
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+function getOperatorsForField(fieldKey, fields) {
+  const field = fields.find((f) => f.key === fieldKey);
+  if (!field) return [];
+  return constants.FIELD_OPERATOR_MAP[field.type] || [];
+}
+function getOperatorConfig(operator) {
+  return constants.OPERATOR_CONFIGS[operator];
+}
+function cloneConditions(root) {
+  return JSON.parse(JSON.stringify(root));
+}
+function duplicateCondition(condition) {
+  return {
+    ...condition,
+    id: generateConditionId()
+  };
+}
+function isConditionsEmpty(root) {
+  return root.groups.every(
+    (group) => group.conditions.every((item) => "fieldKey" in item ? !item.fieldKey : isGroupEmpty(item))
+  );
+}
+function isGroupEmpty(group) {
+  return group.conditions.every(
+    (item) => "fieldKey" in item ? !item.fieldKey : isGroupEmpty(item)
+  );
+}
+function getConditionsDepth(root) {
+  let maxDepth = 0;
+  function getGroupDepth(group, currentDepth) {
+    let depth = currentDepth;
+    for (const item of group.conditions) {
+      if ("logicalOperator" in item) {
+        depth = Math.max(depth, getGroupDepth(item, currentDepth + 1));
+      }
+    }
+    return depth;
+  }
+  for (const group of root.groups) {
+    maxDepth = Math.max(maxDepth, getGroupDepth(group, 1));
+  }
+  return maxDepth;
+}
+function getConditionsCount(root) {
+  let count = 0;
+  function countInGroup(group) {
+    let groupCount = 0;
+    for (const item of group.conditions) {
+      if ("fieldKey" in item) {
+        groupCount++;
+      } else {
+        groupCount += countInGroup(item);
+      }
+    }
+    return groupCount;
+  }
+  for (const group of root.groups) {
+    count += countInGroup(group);
+  }
+  return count;
+}
+exports.cloneConditions = cloneConditions;
+exports.createCondition = createCondition;
+exports.createConditionGroup = createConditionGroup;
+exports.createConditionsRoot = createConditionsRoot;
+exports.createEmptyConditions = createEmptyConditions;
+exports.duplicateCondition = duplicateCondition;
+exports.findCondition = findCondition;
+exports.findGroup = findGroup;
+exports.generateConditionId = generateConditionId;
+exports.generateGroupId = generateGroupId;
+exports.generateGroupName = generateGroupName;
+exports.generateId = generateId;
+exports.generateRootId = generateRootId;
+exports.getConditionPath = getConditionPath;
+exports.getConditionsCount = getConditionsCount;
+exports.getConditionsDepth = getConditionsDepth;
+exports.getGroupPath = getGroupPath;
+exports.getOperatorConfig = getOperatorConfig;
+exports.getOperatorsForField = getOperatorsForField;
+exports.isConditionsEmpty = isConditionsEmpty;
+exports.isOperatorValidForFieldType = isOperatorValidForFieldType;
+exports.validateCondition = validateCondition;
+exports.validateConditionGroup = validateConditionGroup;
+exports.validateConditions = validateConditions;

package/dist/cjs/components/context-input/src/components/context-input-footer.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require$$0 = require("react/jsx-runtime");
+const React = require("react");
+const tv = require("./tv.cjs");
+const tcx = require("../../../../shared/utils/tcx/tcx.cjs");
+const ContextInputFooter = React.memo(
+  React.forwardRef(function ContextInputFooter2(props, ref) {
+    const { children, className, size = "default", handleClick, ...rest } = props;
+    const tv$1 = tv.contextInputFooterTv({ size });
+    return /* @__PURE__ */ require$$0.jsx(
+      "div",
+      {
+        ref,
+        className: tcx.tcx(tv$1, className),
+        onClick: handleClick,
+        ...rest,
+        children
+      }
+    );
+  })
+);
+exports.ContextInputFooter = ContextInputFooter;

package/dist/cjs/components/context-input/src/components/context-input-header.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require$$0 = require("react/jsx-runtime");
+const React = require("react");
+const tv = require("./tv.cjs");
+const tcx = require("../../../../shared/utils/tcx/tcx.cjs");
+const ContextInputHeader = React.memo(
+  React.forwardRef(function ContextInputHeader2(props, ref) {
+    const { children, size = "default", className, handleClick, ...rest } = props;
+    const tv$1 = tv.contextInputHeaderTv({ size });
+    return /* @__PURE__ */ require$$0.jsx(
+      "div",
+      {
+        ref,
+        className: tcx.tcx(tv$1, className),
+        onClick: handleClick,
+        ...rest,
+        children
+      }
+    );
+  })
+);
+exports.ContextInputHeader = ContextInputHeader;

package/dist/cjs/components/context-input/src/components/copy-button.cjs

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require$$0 = require("react/jsx-runtime");
+const index = require("../../../icon-button/dist/index.cjs");
+const iconsReact = require("@choiceform/icons-react");
+const React = require("react");
+const useContextInputEditor = require("../hooks/use-context-input-editor.cjs");
+const slateConverters = require("../utils/slate-converters.cjs");
+const CopyButtonComponent = function CopyButton2({
+  disabled = false,
+  successDuration = 2e3,
+  onClick,
+  ...props
+}) {
+  const [copied, setCopied] = React.useState(false);
+  const editor = React.useContext(useContextInputEditor.ContextInputEditorContext);
+  const handleCopy = async () => {
+    if (!editor) {
+      console.warn("CopyButton must be used within ContextInput");
+      return;
+    }
+    try {
+      const textContent = slateConverters.convertSlateToText(editor.children);
+      if (typeof navigator === "undefined" || !navigator.clipboard) {
+        console.warn("Clipboard API not available");
+        return;
+      }
+      await navigator.clipboard.writeText(textContent);
+      setCopied(true);
+      onClick == null ? void 0 : onClick(textContent);
+      setTimeout(() => setCopied(false), successDuration);
+    } catch (error) {
+      console.error("Failed to copy content:", error);
+    }
+  };
+  return /* @__PURE__ */ require$$0.jsx(
+    index.IconButton,
+    {
+      disabled,
+      onClick: handleCopy,
+      ...props,
+      children: copied ? /* @__PURE__ */ require$$0.jsx(iconsReact.Check, {}) : /* @__PURE__ */ require$$0.jsx(iconsReact.CopySmall, {})
+    }
+  );
+};
+const CopyButton = React.memo(CopyButtonComponent);
+exports.CopyButton = CopyButton;

package/dist/cjs/components/context-input/src/components/insert-mentions-button.cjs

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require$$0 = require("react/jsx-runtime");
+const index = require("../../../icon-button/dist/index.cjs");
+const iconsReact = require("@choiceform/icons-react");
+const React = require("react");
+const slate = require("slate");
+const slateReact = require("slate-react");
+const useContextInputEditor = require("../hooks/use-context-input-editor.cjs");
+const mentionSpacing = require("../utils/mention-spacing.cjs");
+const InsertMentionsButton = React.memo(function InsertMentionsButton2({
+  disabled = false,
+  onClick,
+  ...props
+}) {
+  const editor = useContextInputEditor.useContextInputEditor();
+  const handleInsertMention = () => {
+    try {
+      slateReact.ReactEditor.focus(editor);
+      mentionSpacing.insertSpaceBeforeIfNeeded(editor);
+      slate.Transforms.insertText(editor, "@");
+      onClick == null ? void 0 : onClick();
+    } catch (error) {
+      console.warn("Failed to insert mention trigger:", error);
+    }
+  };
+  return /* @__PURE__ */ require$$0.jsx(
+    index.IconButton,
+    {
+      disabled,
+      onClick: handleInsertMention,
+      ...props,
+      children: /* @__PURE__ */ require$$0.jsx(iconsReact.ApplyVariable, {})
+    }
+  );
+});
+exports.InsertMentionsButton = InsertMentionsButton;