@lostgradient/cinder 0.4.0 → 0.4.1

package/dist/server/index.server-9kas8kq5.js

@@ -0,0 +1,462 @@
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/utilities/sortable-controller.svelte.ts
+import * as $ from "svelte/internal/server";
+import { createContext } from "svelte";
+var [getSortableContext, setSortableContext] = createContext();
+var defaultAnnouncements = {
+  lifted: (itemLabel, position, total) => `${itemLabel}, lifted. Current position ${position} of ${total}. Use arrow keys to move. Space to drop, Escape to cancel.`,
+  moved: (itemLabel, position, total) => `${itemLabel}, moved to position ${position} of ${total}.`,
+  dropped: (itemLabel, position, total) => `${itemLabel}, dropped at position ${position} of ${total}.`,
+  cancelled: (itemLabel) => `Reorder cancelled. ${itemLabel} returned to original position.`
+};
+
+class SortableController {
+  phase = "idle";
+  liftedKey = null;
+  liftedLabel = "";
+  liftedFrom = 0;
+  liftedTo = 0;
+  #announce;
+  #announcements;
+  constructor(options) {
+    this.#announce = options.announce;
+    this.#announcements = { ...defaultAnnouncements, ...options.announcements };
+  }
+  lift(key, fromIndex, itemLabel, total) {
+    if (this.phase === "lifted")
+      return;
+    this.phase = "lifted";
+    this.liftedKey = key;
+    this.liftedLabel = itemLabel;
+    this.liftedFrom = fromIndex;
+    this.liftedTo = fromIndex;
+    this.#announce(this.#announcements.lifted(itemLabel, fromIndex + 1, total));
+  }
+  move(toIndex, itemLabel, total, options = {}) {
+    if (this.phase !== "lifted")
+      return false;
+    const clamped = Math.max(0, Math.min(total - 1, toIndex));
+    if (clamped === this.liftedTo)
+      return false;
+    this.liftedTo = clamped;
+    if (options.announce !== false) {
+      this.#announce(this.#announcements.moved(itemLabel, clamped + 1, total));
+    }
+    return true;
+  }
+  drop(items, itemLabel) {
+    if (this.phase !== "lifted" || this.liftedKey === null)
+      return null;
+    const fromIndex = this.liftedFrom;
+    const toIndex = this.liftedTo;
+    const itemKey = this.liftedKey;
+    this.#announce(this.#announcements.dropped(itemLabel, toIndex + 1, items.length));
+    this.#reset();
+    if (fromIndex === toIndex)
+      return null;
+    if (fromIndex < 0 || fromIndex >= items.length || toIndex < 0 || toIndex >= items.length) {
+      return null;
+    }
+    const nextItems = reorder(items, fromIndex, toIndex);
+    return { nextItems, change: { itemKey, fromIndex, toIndex } };
+  }
+  completeDrop(itemLabel, total) {
+    if (this.phase !== "lifted")
+      return;
+    const boundedTotal = Math.max(1, total);
+    const position = Math.max(1, Math.min(this.liftedTo + 1, boundedTotal));
+    this.#announce(this.#announcements.dropped(itemLabel, position, boundedTotal));
+    this.#reset();
+  }
+  cancel(itemLabel) {
+    if (this.phase !== "lifted")
+      return;
+    this.#announce(this.#announcements.cancelled(itemLabel ?? this.liftedLabel));
+    this.#reset();
+  }
+  reconcileLiftedKey(items, getKey) {
+    if (this.phase !== "lifted" || this.liftedKey === null)
+      return;
+    const currentIndex = items.findIndex((it) => getKey(it) === this.liftedKey);
+    if (currentIndex < 0) {
+      this.#announce(this.#announcements.cancelled(this.liftedLabel));
+      this.#reset();
+      return;
+    }
+    this.liftedTo = Math.max(0, Math.min(items.length - 1, this.liftedTo));
+    if (currentIndex !== this.liftedFrom) {
+      this.liftedFrom = currentIndex;
+    }
+  }
+  #reset() {
+    this.phase = "idle";
+    this.liftedKey = null;
+    this.liftedLabel = "";
+    this.liftedFrom = 0;
+    this.liftedTo = 0;
+  }
+}
+function reorder(items, fromIndex, toIndex) {
+  const result = [...items];
+  const spliced = result.splice(fromIndex, 1);
+  if (spliced.length === 0)
+    return result;
+  result.splice(toIndex, 0, ...spliced);
+  return result;
+}
+
+// src/components/_sortable-item.svelte
+import * as $2 from "svelte/internal/server";
+function _sortable_item($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const rowId = $2.props_id($$renderer2);
+    let {
+      item: _item,
+      itemKey,
+      index,
+      itemLabel,
+      formatHandleLabel,
+      children,
+      handle,
+      instructionsId,
+      total,
+      class: className
+    } = $$props;
+    const context = getSortableContext();
+    let handleEl = null;
+    let rowEl = null;
+    let pointerActive = false;
+    let pointerId = null;
+    let moveRafHandle = null;
+    let scrollRafHandle = null;
+    let latestPointerY = 0;
+    let latestPointerX = 0;
+    let listEl = null;
+    let windowPointerListenersActive = false;
+    let previewX = 0;
+    let previewY = 0;
+    let isDraggingWithPointer = false;
+    let previewWidth = 0;
+    let previewHeight = 0;
+    let previewPortalEl = null;
+    const isLifted = $2.derived(() => context.controller.phase === "lifted" && context.controller.liftedKey === itemKey);
+    const isDropTarget = $2.derived(() => context.controller.phase === "lifted" && context.controller.liftedTo === index);
+    const itemContext = {
+      get isLifted() {
+        return isLifted();
+      },
+      get isDropTarget() {
+        return isDropTarget();
+      },
+      get visualIndex() {
+        return index;
+      },
+      get total() {
+        return total;
+      }
+    };
+    const handleLabel = $2.derived(() => formatHandleLabel(itemLabel));
+    let grabOffsetX = 0;
+    let grabOffsetY = 0;
+    function createPreviewPortal(pointerX, pointerY) {
+      if (typeof document === "undefined")
+        return;
+      if (previewPortalEl)
+        return;
+      if (!rowEl)
+        return;
+      const rect = rowEl.getBoundingClientRect();
+      previewWidth = rect.width;
+      previewHeight = rect.height;
+      grabOffsetX = pointerX - rect.left;
+      grabOffsetY = pointerY - rect.top;
+      const portal = document.createElement("div");
+      portal.setAttribute("data-cinder-drag-preview", "");
+      portal.setAttribute("aria-hidden", "true");
+      portal.setAttribute("inert", "");
+      portal.className = "cinder-sortable-drag-preview";
+      const clone = rowEl.cloneNode(true);
+      clone.removeAttribute("data-sortable-row");
+      clone.removeAttribute("data-key");
+      clone.removeAttribute("data-key-type");
+      clone.removeAttribute("data-row-id");
+      clone.removeAttribute("id");
+      clone.querySelectorAll("[id]").forEach((descendant) => {
+        descendant.removeAttribute("id");
+      });
+      portal.appendChild(clone);
+      portal.style.setProperty("--preview-width", `${previewWidth}px`);
+      portal.style.setProperty("--preview-height", `${previewHeight}px`);
+      portal.style.setProperty("--preview-left", `${rect.left}px`);
+      portal.style.setProperty("--preview-top", `${rect.top}px`);
+      portal.style.setProperty("--preview-dx", "0px");
+      portal.style.setProperty("--preview-dy", "0px");
+      document.body.appendChild(portal);
+      previewPortalEl = portal;
+      isDraggingWithPointer = true;
+    }
+    function updatePreviewPosition(pointerX, pointerY) {
+      if (!previewPortalEl || !rowEl)
+        return;
+      if (typeof document === "undefined")
+        return;
+      const rect = rowEl.getBoundingClientRect();
+      const dx = pointerX - grabOffsetX - rect.left;
+      const dy = pointerY - grabOffsetY - rect.top;
+      previewPortalEl.style.setProperty("--preview-left", `${rect.left}px`);
+      previewPortalEl.style.setProperty("--preview-top", `${rect.top}px`);
+      previewPortalEl.style.setProperty("--preview-dx", `${dx}px`);
+      previewPortalEl.style.setProperty("--preview-dy", `${dy}px`);
+      previewX = pointerX;
+      previewY = pointerY;
+    }
+    function destroyPreviewPortal() {
+      if (moveRafHandle !== null) {
+        cancelAnimationFrame(moveRafHandle);
+        moveRafHandle = null;
+      }
+      if (previewPortalEl) {
+        previewPortalEl.remove();
+        previewPortalEl = null;
+      }
+      isDraggingWithPointer = false;
+    }
+    function addWindowPointerListeners() {
+      if (windowPointerListenersActive || typeof window === "undefined")
+        return;
+      window.addEventListener("pointerup", handleWindowPointerUp);
+      window.addEventListener("pointercancel", handleWindowPointerCancel);
+      windowPointerListenersActive = true;
+    }
+    function removeWindowPointerListeners() {
+      if (!windowPointerListenersActive || typeof window === "undefined")
+        return;
+      window.removeEventListener("pointerup", handleWindowPointerUp);
+      window.removeEventListener("pointercancel", handleWindowPointerCancel);
+      windowPointerListenersActive = false;
+    }
+    function endPointerSession(reason) {
+      if (reason === "drop") {
+        if (moveRafHandle !== null) {
+          cancelAnimationFrame(moveRafHandle);
+          moveRafHandle = null;
+        }
+        recomputeTarget();
+        updatePreviewPosition(latestPointerX, latestPointerY);
+      } else {
+        if (moveRafHandle !== null) {
+          cancelAnimationFrame(moveRafHandle);
+          moveRafHandle = null;
+        }
+      }
+      if (scrollRafHandle !== null) {
+        cancelAnimationFrame(scrollRafHandle);
+        scrollRafHandle = null;
+      }
+      if (pointerId !== null && handleEl?.hasPointerCapture(pointerId)) {
+        try {
+          handleEl.releasePointerCapture(pointerId);
+        } catch {}
+      }
+      destroyPreviewPortal();
+      removeWindowPointerListeners();
+      pointerActive = false;
+      pointerId = null;
+      listEl = null;
+      if (reason === "drop") {
+        context.commitDrop(itemKey, itemLabel);
+      } else {
+        context.cancel(itemLabel);
+      }
+    }
+    function scheduleAutoScroll() {
+      if (!pointerActive)
+        return;
+      const SCROLL_ZONE = 32;
+      const SCROLL_SPEED = 8;
+      const viewportHeight = window.innerHeight;
+      scrollRafHandle = requestAnimationFrame(() => {
+        scrollRafHandle = null;
+        if (!pointerActive)
+          return;
+        if (latestPointerY < SCROLL_ZONE) {
+          window.scrollBy(0, -SCROLL_SPEED);
+          recomputeTarget();
+          scheduleAutoScroll();
+        } else if (latestPointerY > viewportHeight - SCROLL_ZONE) {
+          window.scrollBy(0, SCROLL_SPEED);
+          recomputeTarget();
+          scheduleAutoScroll();
+        }
+      });
+    }
+    function recomputeTarget() {
+      if (!pointerActive)
+        return;
+      if (context.getPointerTarget) {
+        const target2 = context.getPointerTarget({
+          activeKey: itemKey,
+          pointerX: latestPointerX,
+          pointerY: latestPointerY,
+          itemLabel
+        });
+        if (target2)
+          context.move(target2.index, itemLabel, target2.total);
+        return;
+      }
+      if (!listEl)
+        return;
+      const rows = Array.from(listEl.querySelectorAll(":scope > [data-sortable-row]"));
+      const nonLifted = rows.filter((r) => r.dataset["rowId"] !== String(rowId));
+      const midpoints = nonLifted.map((r) => {
+        const rect = r.getBoundingClientRect();
+        return rect.top + rect.height / 2;
+      });
+      const insertionIndex = midpoints.filter((m) => m < latestPointerY).length;
+      const target = Math.max(0, Math.min(insertionIndex, total - 1));
+      context.move(target, itemLabel, total);
+    }
+    function handlePointerDown(event) {
+      if (pointerActive)
+        return;
+      if (event.button !== 0 && event.pointerType === "mouse")
+        return;
+      if (!handleEl)
+        return;
+      listEl = handleEl.closest(".cinder-sortable-list");
+      event.preventDefault();
+      pointerActive = true;
+      pointerId = event.pointerId;
+      latestPointerX = event.clientX;
+      latestPointerY = event.clientY;
+      handleEl.setPointerCapture(event.pointerId);
+      context.lift(itemKey, index, itemLabel, total);
+      if (context.controller.phase !== "lifted" || context.controller.liftedKey !== itemKey) {
+        try {
+          handleEl.releasePointerCapture(event.pointerId);
+        } catch {}
+        pointerActive = false;
+        pointerId = null;
+        listEl = null;
+        return;
+      }
+      createPreviewPortal(event.clientX, event.clientY);
+      updatePreviewPosition(event.clientX, event.clientY);
+      addWindowPointerListeners();
+      scheduleAutoScroll();
+    }
+    function handlePointerMove(event) {
+      if (!pointerActive)
+        return;
+      latestPointerX = event.clientX;
+      latestPointerY = event.clientY;
+      if (moveRafHandle === null) {
+        moveRafHandle = requestAnimationFrame(() => {
+          moveRafHandle = null;
+          recomputeTarget();
+          updatePreviewPosition(latestPointerX, latestPointerY);
+        });
+      }
+      if (scrollRafHandle === null) {
+        scheduleAutoScroll();
+      }
+    }
+    function handlePointerUp(_event) {
+      if (!pointerActive)
+        return;
+      endPointerSession("drop");
+    }
+    function handlePointerCancel(_event) {
+      if (!pointerActive)
+        return;
+      endPointerSession("cancel");
+    }
+    function handleWindowPointerUp(event) {
+      if (!pointerActive || pointerId !== null && event.pointerId !== pointerId)
+        return;
+      endPointerSession("drop");
+    }
+    function handleWindowPointerCancel(event) {
+      if (!pointerActive || pointerId !== null && event.pointerId !== pointerId)
+        return;
+      endPointerSession("cancel");
+    }
+    function handleKeyDown(event) {
+      const { key } = event;
+      if (!isLifted()) {
+        if (key === " " || key === "Enter") {
+          event.preventDefault();
+          context.lift(itemKey, index, itemLabel, total);
+        }
+        return;
+      }
+      switch (key) {
+        case "ArrowLeft":
+        case "ArrowRight":
+          if (context.handleLiftedKeydown?.({ event, itemKey, itemLabel, index, total }) === true) {
+            return;
+          }
+          break;
+        case " ":
+        case "Enter":
+          event.preventDefault();
+          if (pointerActive) {
+            endPointerSession("drop");
+          } else {
+            context.commitDrop(itemKey, itemLabel);
+          }
+          break;
+        case "ArrowDown":
+          event.preventDefault();
+          context.move(context.controller.liftedTo + 1, itemLabel, total);
+          break;
+        case "ArrowUp":
+          event.preventDefault();
+          context.move(context.controller.liftedTo - 1, itemLabel, total);
+          break;
+        case "Home":
+          event.preventDefault();
+          context.move(0, itemLabel, total);
+          break;
+        case "End":
+          event.preventDefault();
+          context.move(total - 1, itemLabel, total);
+          break;
+        case "Escape":
+          event.preventDefault();
+          if (pointerActive) {
+            endPointerSession("cancel");
+          } else {
+            context.cancel(itemLabel);
+          }
+          break;
+        case "Tab":
+          if (pointerActive) {
+            endPointerSession("cancel");
+          } else {
+            context.cancel(itemLabel);
+          }
+          break;
+      }
+    }
+    $$renderer2.push(`<li data-sortable-row=""${$2.attr("data-key", itemKey)}${$2.attr("data-key-type", typeof itemKey)}${$2.attr("data-row-id", rowId)}${$2.attr("data-preview-x", isDraggingWithPointer ? previewX : undefined)}${$2.attr("data-preview-y", isDraggingWithPointer ? previewY : undefined)} aria-roledescription="sortable item"${$2.attr_class($2.clsx(classNames("cinder-sortable-item", isLifted() && isDraggingWithPointer && "cinder-sortable-item--placeholder", isLifted() && !isDraggingWithPointer && "cinder-sortable-item--lifted", !isLifted() && context.controller.phase === "lifted" && "cinder-sortable-item--shifting", className)))}>`);
+    children($$renderer2, itemContext);
+    $$renderer2.push(`<!----> <button type="button" class="cinder-sortable-handle"${$2.attr("aria-label", handleLabel())}${$2.attr("aria-pressed", isLifted())}${$2.attr("aria-describedby", instructionsId)}>`);
+    if (handle) {
+      $$renderer2.push("<!--[0-->");
+      handle($$renderer2, { pressed: isLifted(), label: handleLabel() });
+      $$renderer2.push(`<!---->`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16" fill="currentColor" aria-hidden="true" focusable="false"><path d="M2 4h12v1.5H2zM2 7.25h12v1.5H2zM2 10.5h12v1.5H2z"></path></svg>`);
+    }
+    $$renderer2.push(`<!--]--></button></li>`);
+  });
+}
+
+export { setSortableContext, SortableController, reorder, _sortable_item };
+
+//# debugId=55ACE64FF7D99FBE64756E2164756E21

package/dist/server/index.server-9pbg150a.js

@@ -0,0 +1,9 @@
+import {
+  Dropdown_separator
+} from "./index.server-1k7j69zg.js";
+
+// src/components/dropdown-separator/index.ts
+var dropdown_separator_default = Dropdown_separator;
+export { dropdown_separator_default };
+
+//# debugId=1A41AC049578DDBB64756E2164756E21

package/dist/server/index.server-9r0zg6d9.js

@@ -0,0 +1,102 @@
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/banner/banner.svelte
+import * as $ from "svelte/internal/server";
+import { tick } from "svelte";
+var VARIANT_LABEL = {
+  info: "Information",
+  success: "Success",
+  warning: "Warning",
+  danger: "Error"
+};
+function Banner($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const FOCUSABLE_SELECTOR = 'button:not([disabled]), a[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])';
+    let {
+      variant = "info",
+      dismissible = true,
+      ondismiss,
+      class: className,
+      children,
+      actions,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    let visible = true;
+    let rootElement = undefined;
+    async function handleDismiss() {
+      if (!visible)
+        return;
+      const focusTarget = rootElement ? resolveFocusTarget(rootElement) : null;
+      visible = false;
+      await tick();
+      if (focusTarget?.isConnected)
+        focusTarget.focus();
+      ondismiss?.();
+    }
+    function resolveFocusTarget(bannerElement) {
+      const bannerDocument = bannerElement.ownerDocument;
+      const activeElement = bannerDocument.activeElement;
+      if (!(activeElement instanceof HTMLElement) || !bannerElement.contains(activeElement)) {
+        return null;
+      }
+      return findFocusTarget(bannerElement, bannerDocument, activeElement);
+    }
+    function findFocusTarget(bannerElement, bannerDocument, activeElement) {
+      const candidates = Array.from(bannerDocument.querySelectorAll(FOCUSABLE_SELECTOR)).filter((element) => element !== activeElement && !bannerElement.contains(element) && !element.hidden && element.getAttribute("aria-hidden") !== "true" && !element.closest('[hidden], [inert], [aria-hidden="true"]'));
+      const next = candidates.find((element) => Boolean(bannerElement.compareDocumentPosition(element) & Node.DOCUMENT_POSITION_FOLLOWING));
+      const previous = candidates.findLast((element) => Boolean(bannerElement.compareDocumentPosition(element) & Node.DOCUMENT_POSITION_PRECEDING));
+      return next ?? previous ?? bannerDocument.body;
+    }
+    const restWithoutLiveRegion = $.derived(() => {
+      const {
+        "aria-live": _ariaLive,
+        "aria-atomic": _ariaAtomic,
+        "aria-relevant": _ariaRelevant,
+        ...filtered
+      } = rest;
+      return filtered;
+    });
+    const ariaLabel = $.derived(() => rest["aria-labelledby"] ? undefined : rest["aria-label"] ?? VARIANT_LABEL[variant]);
+    if (visible) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div${$.attributes({
+        ...restWithoutLiveRegion(),
+        class: $.clsx(classNames("cinder-banner", "cinder-_status-surface", "cinder-_status-surface-border", className)),
+        "data-cinder-variant": variant,
+        role: "region",
+        "aria-label": ariaLabel()
+      })}><div class="cinder-banner__content">`);
+      children($$renderer2);
+      $$renderer2.push(`<!----></div> `);
+      if (actions) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="cinder-banner__actions">`);
+        actions($$renderer2);
+        $$renderer2.push(`<!----></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> `);
+      if (dismissible) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<button type="button" class="cinder-_dismiss-button cinder-banner__dismiss" aria-label="Dismiss banner"><svg class="cinder-banner__dismiss-icon" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true"><path d="M6.28 5.22a.75.75 0 00-1.06 1.06L8.94 10l-3.72 3.72a.75.75 0 101.06 1.06L10 11.06l3.72 3.72a.75.75 0 101.06-1.06L11.06 10l3.72-3.72a.75.75 0 00-1.06-1.06L10 8.94 6.28 5.22z"></path></svg></button>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]-->`);
+  });
+}
+
+// src/components/banner/index.ts
+var banner_default = Banner;
+export { Banner, banner_default };
+
+//# debugId=5E0133C16FB5C69664756E2164756E21

package/dist/server/index.server-9r6rts7c.js

@@ -0,0 +1,2 @@
+
+//# debugId=07F0E95D72CB4EA164756E2164756E21

package/dist/server/index.server-9vqgsfds.js

@@ -0,0 +1,9 @@
+import {
+  Spinner
+} from "./index.server-5v74e1fz.js";
+
+// src/components/spinner/index.ts
+var spinner_default = Spinner;
+export { spinner_default };
+
+//# debugId=573503A9929C7F3064756E2164756E21

package/dist/server/index.server-9w7qdn8h.js

@@ -0,0 +1,22 @@
+// src/utilities/use-resize-observer.svelte.ts
+import * as $ from "svelte/internal/server";
+function useResizeObserver(onResize, options = {}) {
+  const { box, enabled = () => true } = options;
+  return (node) => {
+    if (typeof ResizeObserver === "undefined") {
+      return () => {};
+    }
+    let observer = null;
+    const disconnectObserver = () => {
+      observer?.disconnect();
+      observer = null;
+    };
+    return () => {
+      disconnectObserver();
+    };
+  };
+}
+
+export { useResizeObserver };
+
+//# debugId=2BB75AADF13FC22A64756E2164756E21

package/dist/server/index.server-9xyn021z.js

@@ -0,0 +1,9 @@
+import {
+  Select
+} from "./index.server-70c570r3.js";
+
+// src/components/select/index.ts
+var select_default = Select;
+export { select_default };
+
+//# debugId=52D31A49B65C3B5064756E2164756E21

package/dist/server/index.server-abm21gz1.js

@@ -0,0 +1,41 @@
+// src/_internal/field-control.ts
+function describeId(fieldId, hasDescription) {
+  return hasDescription ? `${fieldId}-description` : undefined;
+}
+function errorId(fieldId, hasError) {
+  return hasError ? `${fieldId}-error` : undefined;
+}
+function composeDescribedBy(...ids) {
+  const filtered = ids.flatMap((id) => typeof id === "string" ? id.trim().split(/\s+/).filter(Boolean) : []);
+  const unique = Array.from(new Set(filtered));
+  return unique.length > 0 ? unique.join(" ") : undefined;
+}
+function ariaInvalid(hasError) {
+  return hasError ? "true" : undefined;
+}
+function resolveFieldControl(input) {
+  const resolvedId = input.id ?? input.context?.controlId ?? input.generatedId;
+  const defaultDescriptionId = describeId(resolvedId, input.hasDescription ?? false);
+  const defaultErrorId = errorId(resolvedId, input.hasError ?? false);
+  const ownDescriptionId = defaultDescriptionId && defaultDescriptionId === input.context?.descriptionId && input.localIdNamespace ? `${resolvedId}-${input.localIdNamespace}-description` : defaultDescriptionId;
+  const ownErrorId = defaultErrorId && defaultErrorId === input.context?.errorId && input.localIdNamespace ? `${resolvedId}-${input.localIdNamespace}-error` : defaultErrorId;
+  const descriptionId = ownDescriptionId ?? input.context?.descriptionId;
+  const resolvedErrorId = ownErrorId ?? input.context?.errorId;
+  const explicitInvalid = ariaInvalid(input.hasError ?? false);
+  const consumerInvalid = input.consumerInvalid === true ? "true" : input.consumerInvalid === false ? undefined : input.consumerInvalid ?? undefined;
+  return {
+    id: resolvedId,
+    ownDescriptionId,
+    ownErrorId,
+    descriptionId,
+    errorId: resolvedErrorId,
+    describedBy: composeDescribedBy(descriptionId, ...input.additionalDescribedBy ?? [], resolvedErrorId, input.context?.describedBy, input.consumerDescribedBy),
+    ariaInvalid: explicitInvalid ?? input.context?.invalid ?? consumerInvalid,
+    required: input.required ?? input.context?.required ?? false,
+    disabled: input.disabled ?? input.context?.disabled ?? false
+  };
+}
+
+export { describeId, errorId, composeDescribedBy, ariaInvalid, resolveFieldControl };
+
+//# debugId=93C31232E56F806664756E2164756E21