@prolibu-suite/cobalt-core 0.1.2 → 0.2.0

package/dist/cjs/{positioning-DozpXyBd.js → positioning-DwHW399W.js}

@@ -63,7 +63,7 @@ function computePosition(triggerRect, panelRect, options) {
             left = triggerRect.right + offset;
         else
             left = triggerRect.left - panelRect.width - offset;
-        const align = placement.split('-')[1] || 'start';
+        const align = placement.split('-')[1] || 'center';
         if (align === 'start')
             top = triggerRect.top;
         else if (align === 'end')
@@ -76,7 +76,7 @@ function computePosition(triggerRect, panelRect, options) {
             top = triggerRect.top - panelRect.height - offset;
         else
             top = triggerRect.bottom + offset;
-        const align = placement.split('-')[1] || 'start';
+        const align = placement.split('-')[1] || 'center';
         if (align === 'start')
             left = triggerRect.left;
         else if (align === 'end')
@@ -98,8 +98,8 @@ function computePosition(triggerRect, panelRect, options) {
  * Walk up the FLATTENED tree (after slot projection) to find the nearest
  * ancestor that creates a containing block for `position: fixed`. Per CSS spec,
  * `transform`, `perspective`, `filter`, `backdrop-filter`,
- * `contain: paint|layout|strict|content`, or `will-change: transform` all trap
- * `position: fixed`.
+ * `contain: paint|layout|strict|content`, `will-change: transform`, or
+ * `container-type` (size | inline-size) all trap `position: fixed`.
  *
  * The flattened tree differs from the DOM tree in two places:
  *   1. Shadow boundaries: `parentElement` stops at the shadow root, so we
@@ -108,23 +108,30 @@ function computePosition(triggerRect, panelRect, options) {
  *      INSIDE the host's shadow, not its DOM parent. We use `assignedSlot`
  *      to follow that projection.
  */
-function getOffsetAncestor(el) {
-    const next = (n) => {
-        var _a, _b;
-        if (!n)
-            return null;
-        const assignedSlot = n.assignedSlot;
-        if (assignedSlot)
-            return assignedSlot.parentElement;
-        const parent = n.parentElement;
-        if (parent)
-            return parent;
-        const root = (_b = (_a = n).getRootNode) === null || _b === void 0 ? void 0 : _b.call(_a);
-        if (root instanceof ShadowRoot)
-            return root.host;
+/**
+ * Step to the next ancestor in the FLATTENED tree (slot projection + shadow
+ * boundaries), so traversal works for elements slotted into a shadow-DOM host:
+ *   1. `assignedSlot` → the slot's parent inside the host's shadow (projection).
+ *   2. light-DOM `parentElement`.
+ *   3. at a shadow root top, cross to the host element.
+ */
+function flattenedParent(n) {
+    var _a, _b;
+    if (!n)
         return null;
-    };
-    let node = next(el);
+    const assignedSlot = n.assignedSlot;
+    if (assignedSlot)
+        return assignedSlot.parentElement;
+    const parent = n.parentElement;
+    if (parent)
+        return parent;
+    const root = (_b = (_a = n).getRootNode) === null || _b === void 0 ? void 0 : _b.call(_a);
+    if (root instanceof ShadowRoot)
+        return root.host;
+    return null;
+}
+function getOffsetAncestor(el) {
+    let node = flattenedParent(el);
     while (node && node !== document.body && node !== document.documentElement) {
         const style = getComputedStyle(node);
         const transform = style.transform && style.transform !== 'none';
@@ -133,23 +140,31 @@ function getOffsetAncestor(el) {
         const backdropFilter = style.backdropFilter && style.backdropFilter !== 'none';
         const willChange = (style.willChange || '').includes('transform');
         const contain = /paint|layout|strict|content/.test(style.contain || '');
-        if (transform || perspective || filter || backdropFilter || willChange || contain) {
+        const containerType = style.containerType && style.containerType !== 'normal';
+        if (transform || perspective || filter || backdropFilter || willChange || contain || containerType) {
             return node;
         }
-        node = next(node);
+        node = flattenedParent(node);
     }
     return null;
 }
 /**
  * Find the nearest ancestor of `start` that scrolls (overflow).
+ *
+ * Walks the FLATTENED tree (via {@link flattenedParent}) so it can reach a
+ * scroll container that lives in an ancestor's shadow DOM — e.g. `co-popover`
+ * slotted into a `<co-drawer>`/`<co-modal>` whose `__body` (the actual scroller)
+ * is inside the host's shadow. A plain `parentNode` walk never reaches it, which
+ * left popovers detached on modal-body scroll (scroll events are not composed,
+ * so the window capture listener never sees them either).
  */
 function findNearestScrollParent(start) {
-    let node = start.parentElement;
-    while (node && node !== document.body) {
+    let node = flattenedParent(start);
+    while (node && node !== document.body && node !== document.documentElement) {
         if (node.scrollHeight > node.clientHeight || node.scrollWidth > node.clientWidth) {
             return node;
         }
-        node = node.parentElement;
+        node = flattenedParent(node);
     }
     return null;
 }

package/dist/cjs/requiredMark-DA6y-4rp.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var index = require('./index-DoFnrUVH.js');
+
+/**
+ * Shared required-field indicator for every co-* form field, so they all render
+ * the same `* (required)` marker. The asterisk is literal; the "(required)"
+ * caption text comes from the `--co-field-required-text` CSS custom property
+ * (host app sets it per locale) with an English fallback. Styling lives in the
+ * `.co-field-required` / `.co-field-required__caption` rules each component's
+ * CSS carries (next to the `::before` content rule) — NOT inline, so hosts can
+ * restyle via `::part(required)`.
+ */
+const RequiredMark = ({ required }) => required ? (index.h("span", { class: "co-field-required", part: "required" }, "*", index.h("span", { class: "co-field-required__caption" }))) : null;
+
+exports.RequiredMark = RequiredMark;