@bpmn-io/form-js-editor 1.19.0 → 1.20.0

package/dist/index.es.js

@@ -5700,6 +5700,8 @@ function Tooltip(props) {
     hideDelay = 250
   } = props;
   const [visible, setVisible] = useState(false);
+  const [tooltipPosition, setTooltipPosition] = useState(null);
+  const [arrowOffset, setArrowOffset] = useState(null);
   const showTimeoutRef = useRef(null);
   const hideTimeoutRef = useRef(null);
   const wrapperRef = useRef(null);
@@ -5753,6 +5755,20 @@ function Tooltip(props) {
       document.removeEventListener('mousedown', handleClickOutside);
     };
   }, [visible, hide]);
+  useLayoutEffect(() => {
+    if (!visible || position) {
+      setTooltipPosition(null);
+      setArrowOffset(null);
+      return;
+    }
+    if (!wrapperRef.current || !tooltipRef.current) return;
+    const {
+      tooltipPosition: newPosition,
+      arrowOffset: newArrowOffset
+    } = getTooltipPosition(wrapperRef.current, tooltipRef.current, direction);
+    setTooltipPosition(newPosition);
+    setArrowOffset(newArrowOffset);
+  }, [visible, position]);
   const handleMouseLeave = ({
     relatedTarget
   }) => {
@@ -5788,12 +5804,14 @@ function Tooltip(props) {
     e.code === 'Escape' && hide(false);
   };
   const renderTooltip = () => {
+    const tooltipStyle = position || (tooltipPosition ? `right: ${tooltipPosition.right}; top: ${tooltipPosition.top}px;` : undefined);
+    const arrowStyle = arrowOffset != null ? `margin-top: ${arrowOffset}px;` : undefined;
     return jsxs("div", {
       class: `bio-properties-panel-tooltip ${direction}`,
       role: "tooltip",
       id: "bio-properties-panel-tooltip",
       "aria-labelledby": forId,
-      style: position || getTooltipPosition(wrapperRef.current),
+      style: tooltipStyle,
       ref: tooltipRef,
       onClick: e => e.stopPropagation(),
       onMouseEnter: handleTooltipMouseEnter,
@@ -5802,7 +5820,8 @@ function Tooltip(props) {
         class: "bio-properties-panel-tooltip-content",
         children: value
       }), jsx("div", {
-        class: "bio-properties-panel-tooltip-arrow"
+        class: "bio-properties-panel-tooltip-arrow",
+        style: arrowStyle
       })]
     });
   };
@@ -5821,11 +5840,47 @@ function Tooltip(props) {
 
 // helper
 
-function getTooltipPosition(refElement) {
+function getTooltipPosition(refElement, tooltipElement, direction) {
+  if (!refElement) {
+    return {
+      tooltipPosition: null,
+      arrowOffset: null
+    };
+  }
   const refPosition = refElement.getBoundingClientRect();
   const right = `calc(100% - ${refPosition.x}px)`;
-  const top = `${refPosition.top - 10}px`;
-  return `right: ${right}; top: ${top};`;
+  let top = refPosition.top - 10;
+  let arrowOffset = null;
+
+  // Ensure that the tooltip is within the viewport, adjust the top position if needed.
+  // This is only relevant for the 'right' direction for now
+  if (tooltipElement && direction === 'right') {
+    const tooltipRect = tooltipElement.getBoundingClientRect();
+    const viewportHeight = window.innerHeight;
+    const minTop = 0;
+    const maxTop = viewportHeight - tooltipRect.height;
+    const originalTop = top;
+    if (top > maxTop) {
+      top = maxTop;
+    }
+    if (top < minTop) {
+      top = minTop;
+    }
+
+    // Adjust the arrow position if the tooltip had to be moved to stay within viewport
+    if (top !== originalTop) {
+      const defaultMarginTop = 16;
+      const topDiff = top - originalTop;
+      arrowOffset = defaultMarginTop - topDiff;
+    }
+  }
+  return {
+    tooltipPosition: {
+      right,
+      top
+    },
+    arrowOffset
+  };
 }
 
 /**
@@ -6063,12 +6118,17 @@ function useStickyIntersectionObserver(ref, scrollContainerSelector, setSticky)
  * The `callback` reference is static and can be safely used in external
  * libraries or as a prop that does not cause rerendering of children.
  *
+ * The ref update is deferred to useLayoutEffect to prevent stale-closure
+ * bugs when Chrome fires blur on elements removed during re-render.
+ *
  * @param {Function} callback function with changing reference
  * @returns {Function} static function reference
  */
 function useStaticCallback(callback) {
   const callbackRef = useRef(callback);
-  callbackRef.current = callback;
+  useLayoutEffect(() => {
+    callbackRef.current = callback;
+  });
   return useCallback((...args) => callbackRef.current(...args), []);
 }
 function useElementVisible(element) {
@@ -7324,7 +7384,7 @@ function ToggleSwitchEntry(props) {
       inline: inline,
       tooltip: tooltip,
       element: element
-    }), jsx(Description$1, {
+    }, element), jsx(Description$1, {
       forId: id,
       element: element,
       value: description
@@ -7497,7 +7557,7 @@ function prefixId$6(id) {
 const noop$2 = () => {};
 
 /**
- * @typedef {'required'|'optional'|'static'} FeelType
+ * @typedef {'required'|'optional'|'optional-default-enabled'|'static'} FeelType
  */
 
 /**
@@ -7540,7 +7600,7 @@ function FeelTextfield(props) {
     OptionalComponent = OptionalFeelInput,
     tooltip
   } = props;
-  const [localValue, setLocalValue] = useState(value);
+  const [localValue, setLocalValue] = useState(getInitialFeelLocalValue(feel, value));
   const editorRef = useShowEntryEvent(id);
   const containerRef = useRef();
   const onInput = useCallback(newValue => {
@@ -7549,8 +7609,8 @@ function FeelTextfield(props) {
     const newModelValue = newValue === '' || newValue === '=' ? undefined : newValue;
     commitValue(newModelValue);
   }, [commitValue]);
-  const feelActive = isString(localValue) && localValue.startsWith('=') || feel === 'required';
-  const feelOnlyValue = isString(localValue) && localValue.startsWith('=') ? localValue.substring(1) : localValue;
+  const feelActive = isFeelActive(feel, localValue);
+  const feelOnlyValue = getFeelValue(localValue);
   const feelLanguageContext = useContext(FeelLanguageContext);
   const [focus, _setFocus] = useState(undefined);
   const {
@@ -7613,7 +7673,7 @@ function FeelTextfield(props) {
   };
   const handleOnKeyDown = e => {
     if (isCmdWithChar(e)) {
-      handleInput.flush();
+      handleInput.flush?.();
     }
   };
   const handleLint = useStaticCallback((lint = []) => {
@@ -7737,7 +7797,7 @@ function FeelTextfield(props) {
       ref: containerRef,
       children: [jsx(FeelIndicator, {
         active: feelActive,
-        disabled: feel !== 'optional' || disabled,
+        disabled: !isFeelOptional(feel) || disabled,
         onClick: handleFeelToggle
       }), feelActive ? jsx(FeelEditor, {
         name: id,
@@ -8195,6 +8255,68 @@ function prefixId$5(id) {
   return `bio-properties-panel-${id}`;
 }
 
+/**
+ * Determine if FEEL is optional for the configured {@link FeelType}.
+ *
+ * @param {FeelType} feelType
+ *
+ * @return {boolean}
+ */
+function isFeelOptional(feelType) {
+  return feelType === 'optional' || feelType === 'optional-default-enabled';
+}
+
+/**
+ * Determine if FEEL editing is currently active.
+ *
+ * @param {FeelType} feelType
+ * @param {string} localValue
+ *
+ * @return {boolean}
+ */
+function isFeelActive(feelType, localValue) {
+  if (feelType === 'required') {
+    return true;
+  }
+  if (isString(localValue)) {
+    if (localValue.startsWith('=')) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * @template T
+ * @param {T} value
+ *
+ * @return {string|T}
+ */
+function getFeelValue(value) {
+  if (isString(value) && value.startsWith('=')) {
+    return value.substring(1);
+  }
+  return value;
+}
+
+/**
+ * Initialize local FEEL value.
+ *
+ * `optional-default-enabled` starts in FEEL mode if no value or empty string is provided.
+ *
+ * @template T
+ * @param {FeelType} feelType
+ * @param {T} value
+ *
+ * @return {string|T}
+ */
+function getInitialFeelLocalValue(feelType, value) {
+  if (feelType === 'optional-default-enabled' && (value === undefined || value === '')) {
+    return '=';
+  }
+  return value;
+}
+
 /**
  * @typedef { { value: string, label: string, disabled: boolean, children: { value: string, label: string, disabled: boolean } } } Option
  */
@@ -8445,7 +8567,7 @@ function TextArea(props) {
   };
   const handleOnKeyDown = e => {
     if (isCmdWithChar(e)) {
-      handleInput.flush();
+      handleInput.flush?.();
     }
   };
   useLayoutEffect(() => {
@@ -8660,7 +8782,7 @@ function Textfield(props) {
   }, [value]);
   const handleOnKeyDown = e => {
     if (isCmdWithChar(e)) {
-      handleInput.flush();
+      handleInput.flush?.();
     }
   };
   return jsxs("div", {
@@ -9028,6 +9150,7 @@ function Title(props) {
       class: "bio-properties-panel-popup__title",
       children: title
     }), children, showCloseButton && jsx("button", {
+      type: "button",
       title: closeButtonTooltip,
       class: "bio-properties-panel-popup__close",
       onClick: onClose,
@@ -13800,7 +13923,7 @@ function CustomPropertiesGroup(field, editField) {
       event.stopPropagation();
       return editField(field, ['properties'], removeKey(properties, key));
     };
-    const id = `property-${field.id}-${index}`;
+    const id = `property-${index}`;
     return {
       autoFocusEntry: id + '-key',
       entries: CustomValueEntry({