@evinvest/uikit 0.18.0 → 0.20.0

package/dist/lib/cn.js

@@ -0,0 +1,12 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  if (inputs.length === 2 && typeof inputs[0] === "string" && !inputs[1]) {
+    return inputs[0];
+  }
+  return twMerge(clsx(inputs));
+}
+export {
+  cn
+};
+//# sourceMappingURL=cn.js.map

package/dist/lib/cn.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/cn.ts"],"sourcesContent":["import { clsx, type ClassValue } from \"clsx\";\nimport { twMerge } from \"tailwind-merge\";\n\n/**\n * Fuses class fragments into one string with real Tailwind conflict resolution:\n * `clsx` drops falsy fragments and joins the rest, `tailwind-merge` resolves\n * conflicting utilities so the rightmost wins (`cn(\"p-4\", \"p-2\") === \"p-2\"`). A\n * caller's `className` override, passed last, therefore beats the base classes.\n *\n * `twMerge` parses every utility on every render, and the overwhelmingly common\n * call is one kit constant plus a `className` override that is absent — so that\n * call returns the constant untouched.\n *\n * The Rust mirror is the `cn!` macro in `ev_lib::uikit` (`tailwind_fuse::tw_merge!`).\n */\nexport function cn(...inputs: ClassValue[]): string {\n  if (inputs.length === 2 && typeof inputs[0] === \"string\" && !inputs[1]) {\n    return inputs[0];\n  }\n  return twMerge(clsx(inputs));\n}\n"],"mappings":"AAAA,SAAS,YAA6B;AACtC,SAAS,eAAe;AAcjB,SAAS,MAAM,QAA8B;AAClD,MAAI,OAAO,WAAW,KAAK,OAAO,OAAO,CAAC,MAAM,YAAY,CAAC,OAAO,CAAC,GAAG;AACtE,WAAO,OAAO,CAAC;AAAA,EACjB;AACA,SAAO,QAAQ,KAAK,MAAM,CAAC;AAC7B;","names":[]}

package/dist/lib/focus.js

@@ -0,0 +1,5 @@
+import { FILLED_FOCUS_RING } from "../generated/focus.js";
+export {
+  FILLED_FOCUS_RING
+};
+//# sourceMappingURL=focus.js.map

package/dist/lib/focus.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/focus.ts"],"sourcesContent":["/**\n * The focus indicator for a control that paints a fill (lib#129): the solid\n * ring standing 2px off the control instead of the kit's 50 % halo. The class\n * tables that paint a fill already carry it (`rust/classes/src/focus.rs` says\n * why); this is for a filled control of the caller's own.\n */\nexport { FILLED_FOCUS_RING } from \"../generated/focus\";\n"],"mappings":"AAMA,SAAS,yBAAyB;","names":[]}

package/dist/palette-cli.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import {
+  PaletteError,
+  brandFromToml,
+  readContract,
+  renderPalette
+} from "./chunk-3IPB4QQJ.js";
+
+// src/palette/cli.ts
+import { readFileSync, writeFileSync } from "fs";
+import { basename } from "path";
+import { parseArgs } from "util";
+var USAGE = `usage: evinvest-palette --brand <slug> [--out <file.css>] <brand.toml>
+
+Writes the brand's palette as a flat sheet scoped to [data-brand="<slug>"],
+after checking both polarities against the contract in @evinvest/uikit's
+styles/theme.css. Prints to stdout without --out.`;
+function main() {
+  const { values, positionals } = parseArgs({
+    options: { brand: { type: "string" }, out: { type: "string" }, help: { type: "boolean", short: "h" } },
+    allowPositionals: true
+  });
+  const [input] = positionals;
+  if (values.help || !values.brand || !input || positionals.length > 1) {
+    console.error(USAGE);
+    return values.help ? 0 : 2;
+  }
+  const contract = readContract(readFileSync(new URL("../styles/theme.css", import.meta.url), "utf8"));
+  const sheet = renderPalette(values.brand, brandFromToml(readFileSync(input, "utf8")), contract, basename(input));
+  if (values.out) writeFileSync(values.out, sheet);
+  else process.stdout.write(sheet);
+  return 0;
+}
+try {
+  process.exitCode = main();
+} catch (error) {
+  if (error instanceof PaletteError) console.error(error.message);
+  else throw error;
+  process.exitCode = 1;
+}
+//# sourceMappingURL=palette-cli.js.map

package/dist/palette-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/palette/cli.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { readFileSync, writeFileSync } from \"node:fs\";\nimport { basename } from \"node:path\";\nimport { parseArgs } from \"node:util\";\n\nimport { brandFromToml, PaletteError, renderPalette } from \"./brand\";\nimport { readContract } from \"./contract\";\n\nconst USAGE = `usage: evinvest-palette --brand <slug> [--out <file.css>] <brand.toml>\n\nWrites the brand's palette as a flat sheet scoped to [data-brand=\"<slug>\"],\nafter checking both polarities against the contract in @evinvest/uikit's\nstyles/theme.css. Prints to stdout without --out.`;\n\nfunction main(): number {\n  const { values, positionals } = parseArgs({\n    options: { brand: { type: \"string\" }, out: { type: \"string\" }, help: { type: \"boolean\", short: \"h\" } },\n    allowPositionals: true,\n  });\n  const [input] = positionals;\n  if (values.help || !values.brand || !input || positionals.length > 1) {\n    console.error(USAGE);\n    return values.help ? 0 : 2;\n  }\n\n  // Shipped beside `dist/`, so the contract is always the installed kit's own.\n  const contract = readContract(readFileSync(new URL(\"../styles/theme.css\", import.meta.url), \"utf8\"));\n  const sheet = renderPalette(values.brand, brandFromToml(readFileSync(input, \"utf8\")), contract, basename(input));\n  if (values.out) writeFileSync(values.out, sheet);\n  else process.stdout.write(sheet);\n  return 0;\n}\n\ntry {\n  process.exitCode = main();\n} catch (error) {\n  // A bad brand file is the user's input, not a crash: the message, no stack.\n  if (error instanceof PaletteError) console.error(error.message);\n  else throw error;\n  process.exitCode = 1;\n}\n"],"mappings":";;;;;;;;;AACA,SAAS,cAAc,qBAAqB;AAC5C,SAAS,gBAAgB;AACzB,SAAS,iBAAiB;AAK1B,IAAM,QAAQ;AAAA;AAAA;AAAA;AAAA;AAMd,SAAS,OAAe;AACtB,QAAM,EAAE,QAAQ,YAAY,IAAI,UAAU;AAAA,IACxC,SAAS,EAAE,OAAO,EAAE,MAAM,SAAS,GAAG,KAAK,EAAE,MAAM,SAAS,GAAG,MAAM,EAAE,MAAM,WAAW,OAAO,IAAI,EAAE;AAAA,IACrG,kBAAkB;AAAA,EACpB,CAAC;AACD,QAAM,CAAC,KAAK,IAAI;AAChB,MAAI,OAAO,QAAQ,CAAC,OAAO,SAAS,CAAC,SAAS,YAAY,SAAS,GAAG;AACpE,YAAQ,MAAM,KAAK;AACnB,WAAO,OAAO,OAAO,IAAI;AAAA,EAC3B;AAGA,QAAM,WAAW,aAAa,aAAa,IAAI,IAAI,uBAAuB,YAAY,GAAG,GAAG,MAAM,CAAC;AACnG,QAAM,QAAQ,cAAc,OAAO,OAAO,cAAc,aAAa,OAAO,MAAM,CAAC,GAAG,UAAU,SAAS,KAAK,CAAC;AAC/G,MAAI,OAAO,IAAK,eAAc,OAAO,KAAK,KAAK;AAAA,MAC1C,SAAQ,OAAO,MAAM,KAAK;AAC/B,SAAO;AACT;AAEA,IAAI;AACF,UAAQ,WAAW,KAAK;AAC1B,SAAS,OAAO;AAEd,MAAI,iBAAiB,aAAc,SAAQ,MAAM,MAAM,OAAO;AAAA,MACzD,OAAM;AACX,UAAQ,WAAW;AACrB;","names":[]}

package/dist/palette.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The colour contract, read out of the kit's own token sheet rather than
+ * restated here: `@theme inline` maps every name the class tables can paint
+ * (`--color-X: var(--X)`), and the derived rule lists the ones the contract
+ * computes from the rest. A palette owes the difference.
+ */
+interface Contract {
+    /** Names every palette scope must declare. */
+    required: readonly string[];
+    /** Names the contract derives from the palette; a palette may override them. */
+    derived: readonly string[];
+    /** The tokens each derived default reads, so a palette's references can be checked for cycles through them. */
+    derivedFrom: Readonly<Record<string, readonly string[]>>;
+}
+/** The rule the derived tokens live on — see `theme.css`, the contract half of `tokens.css`. */
+declare const DERIVED_SCOPE = ":where(:root, .dark, .light, [data-brand])";
+interface CssRule {
+    selector: string;
+    /** Custom properties declared directly in the rule, in source order. */
+    declarations: Map<string, string>;
+}
+/**
+ * Top-level and `@media`-nested rules of a flat sheet, comments stripped. Only
+ * as much CSS as a token sheet is made of: no strings containing braces.
+ */
+declare function readRules(css: string): CssRule[];
+declare function readContract(css: string): Contract;
+
+type PolarityName = "light" | "dark";
+declare const POLARITIES: readonly PolarityName[];
+/** A brand's palette: one value per contract name, for each polarity. */
+interface BrandConfig {
+    colors: Record<PolarityName, Record<string, string>>;
+    /** `--brand-mark`: the URL `<Logo>` masks. */
+    mark?: string;
+    /** `--brand-aspect`: the mark's width / height, e.g. `"387 / 335"`. */
+    markAspect?: string;
+    /** `--brand-font-<role>`: a family name per role; unset roles keep the kit's. */
+    fonts?: Partial<Record<FontRole, string>>;
+}
+type FontRole = "sans" | "display" | "mono";
+declare const FONT_ROLES: readonly FontRole[];
+/** Every problem with a brand file at once, so one run fixes them all. */
+declare class PaletteError extends Error {
+    readonly problems: readonly string[];
+    constructor(problems: readonly string[]);
+}
+/**
+ * Reads the aquafix `brand.toml` shape: `[colors.light]` and `[colors.dark]`
+ * keyed by contract name, optional top-level `mark` / `mark-aspect`, and the
+ * family names in `[fonts]` (`sans` or `text`, `display`, `mono`). The rest of
+ * `[fonts]` and every other table (`[print]`, …) belong to other tools and are
+ * ignored — loading the font files is the site's job, not the palette's.
+ */
+declare function brandFromToml(text: string): BrandConfig;
+/** The problems with `config` against `contract`; empty when it is complete. */
+declare function validateBrand(config: BrandConfig, contract: Contract): string[];
+/**
+ * A flat sheet scoping `config` under `[data-brand="<brand>"]`: light is the
+ * brand's default and `.light` / `.dark` beneath it pick a polarity. Selectors
+ * outrank the zero-specificity EV palette, so import order does not matter.
+ * Throws a {@link PaletteError} when a scope is incomplete — Tailwind answers an
+ * undefined token with no rule at all, so a hole would be silent on the page.
+ */
+declare function renderPalette(brand: string, config: BrandConfig, contract: Contract, source?: string): string;
+
+/**
+ * The subset of TOML a brand file is written in: `[table.headers]`, bare keys,
+ * and single-line values that are a basic string, a number, a boolean, or a
+ * flat array of those. Anything else is an error naming the line, rather than a
+ * silent misread — the kit stays dependency-free, and a brand file has no use
+ * for the rest of the language.
+ */
+type TomlValue = string | number | boolean | TomlValue[];
+interface TomlTable {
+    [key: string]: TomlValue | TomlTable;
+}
+declare function parseToml(text: string): TomlTable;
+
+export { type BrandConfig, type Contract, type CssRule, DERIVED_SCOPE, FONT_ROLES, type FontRole, POLARITIES, PaletteError, type PolarityName, type TomlTable, type TomlValue, brandFromToml, parseToml, readContract, readRules, renderPalette, validateBrand };

package/dist/palette.js

@@ -0,0 +1,25 @@
+import {
+  DERIVED_SCOPE,
+  FONT_ROLES,
+  POLARITIES,
+  PaletteError,
+  brandFromToml,
+  parseToml,
+  readContract,
+  readRules,
+  renderPalette,
+  validateBrand
+} from "./chunk-3IPB4QQJ.js";
+export {
+  DERIVED_SCOPE,
+  FONT_ROLES,
+  POLARITIES,
+  PaletteError,
+  brandFromToml,
+  parseToml,
+  readContract,
+  readRules,
+  renderPalette,
+  validateBrand
+};
+//# sourceMappingURL=palette.js.map

package/dist/palette.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/primitives/dismissable-layer.js

@@ -0,0 +1,35 @@
+"use client";
+import * as React from "react";
+function useDismissableLayer(opts) {
+  const { enabled, onDismiss, exclude } = opts;
+  const ref = React.useRef(null);
+  const onDismissRef = React.useRef(onDismiss);
+  React.useEffect(() => {
+    onDismissRef.current = onDismiss;
+  });
+  React.useEffect(() => {
+    if (!enabled) return;
+    function onPointerDown(event) {
+      const target = event.target;
+      if (ref.current && target && ref.current.contains(target)) return;
+      for (const r of exclude ?? []) {
+        if (r.current && target && r.current.contains(target)) return;
+      }
+      onDismissRef.current();
+    }
+    function onKeyDown(event) {
+      if (event.key === "Escape") onDismissRef.current();
+    }
+    document.addEventListener("pointerdown", onPointerDown, true);
+    document.addEventListener("keydown", onKeyDown);
+    return () => {
+      document.removeEventListener("pointerdown", onPointerDown, true);
+      document.removeEventListener("keydown", onKeyDown);
+    };
+  }, [enabled, exclude]);
+  return ref;
+}
+export {
+  useDismissableLayer
+};
+//# sourceMappingURL=dismissable-layer.js.map

package/dist/primitives/dismissable-layer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/primitives/dismissable-layer.tsx"],"sourcesContent":["\"use client\";\n\nimport * as React from \"react\";\n\n/**\n * Calls `onDismiss` on Escape or on a pointer-down outside the layer — the\n * dep-light core of every overlay's \"click away to close\". Pass refs to any\n * nodes that should NOT count as outside (e.g. the trigger), via `exclude`.\n *\n * Mirrors the dismiss behaviour Rust expresses with a full-screen backdrop.\n */\nexport function useDismissableLayer(opts: {\n  enabled: boolean;\n  onDismiss: () => void;\n  exclude?: Array<React.RefObject<Element | null>>;\n}): React.RefObject<HTMLDivElement | null> {\n  const { enabled, onDismiss, exclude } = opts;\n  const ref = React.useRef<HTMLDivElement | null>(null);\n  const onDismissRef = React.useRef(onDismiss);\n  React.useEffect(() => {\n    onDismissRef.current = onDismiss;\n  });\n\n  React.useEffect(() => {\n    if (!enabled) return;\n\n    function onPointerDown(event: PointerEvent) {\n      const target = event.target as Node | null;\n      if (ref.current && target && ref.current.contains(target)) return;\n      for (const r of exclude ?? []) {\n        if (r.current && target && r.current.contains(target)) return;\n      }\n      onDismissRef.current();\n    }\n\n    function onKeyDown(event: KeyboardEvent) {\n      if (event.key === \"Escape\") onDismissRef.current();\n    }\n\n    document.addEventListener(\"pointerdown\", onPointerDown, true);\n    document.addEventListener(\"keydown\", onKeyDown);\n    return () => {\n      document.removeEventListener(\"pointerdown\", onPointerDown, true);\n      document.removeEventListener(\"keydown\", onKeyDown);\n    };\n  }, [enabled, exclude]);\n\n  return ref;\n}\n"],"mappings":";AAEA,YAAY,WAAW;AAShB,SAAS,oBAAoB,MAIO;AACzC,QAAM,EAAE,SAAS,WAAW,QAAQ,IAAI;AACxC,QAAM,MAAM,MAAM,OAA8B,IAAI;AACpD,QAAM,eAAe,MAAM,OAAO,SAAS;AAC3C,QAAM,UAAU,MAAM;AACpB,iBAAa,UAAU;AAAA,EACzB,CAAC;AAED,QAAM,UAAU,MAAM;AACpB,QAAI,CAAC,QAAS;AAEd,aAAS,cAAc,OAAqB;AAC1C,YAAM,SAAS,MAAM;AACrB,UAAI,IAAI,WAAW,UAAU,IAAI,QAAQ,SAAS,MAAM,EAAG;AAC3D,iBAAW,KAAK,WAAW,CAAC,GAAG;AAC7B,YAAI,EAAE,WAAW,UAAU,EAAE,QAAQ,SAAS,MAAM,EAAG;AAAA,MACzD;AACA,mBAAa,QAAQ;AAAA,IACvB;AAEA,aAAS,UAAU,OAAsB;AACvC,UAAI,MAAM,QAAQ,SAAU,cAAa,QAAQ;AAAA,IACnD;AAEA,aAAS,iBAAiB,eAAe,eAAe,IAAI;AAC5D,aAAS,iBAAiB,WAAW,SAAS;AAC9C,WAAO,MAAM;AACX,eAAS,oBAAoB,eAAe,eAAe,IAAI;AAC/D,eAAS,oBAAoB,WAAW,SAAS;AAAA,IACnD;AAAA,EACF,GAAG,CAAC,SAAS,OAAO,CAAC;AAErB,SAAO;AACT;","names":[]}

package/dist/primitives/focus-scope.js

@@ -0,0 +1,58 @@
+"use client";
+import * as React from "react";
+const FOCUSABLE = [
+  "a[href]",
+  "button:not([disabled])",
+  "textarea:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "[tabindex]"
+].map((sel) => `${sel}:not([tabindex="-1"])`).join(",");
+function focusCandidates(root) {
+  return Array.from(root.querySelectorAll(FOCUSABLE));
+}
+function focusable(root) {
+  return focusCandidates(root).filter(
+    (el) => el.offsetWidth > 0 || el.offsetHeight > 0 || el === document.activeElement
+  );
+}
+function useFocusScope(enabled) {
+  const ref = React.useRef(null);
+  React.useEffect(() => {
+    if (!enabled) return;
+    const root = ref.current;
+    if (!root) return;
+    const previouslyFocused = document.activeElement;
+    const first = focusable(root)[0];
+    (first ?? root).focus();
+    function onKeyDown(event) {
+      if (event.key !== "Tab" || !root) return;
+      const items = focusable(root);
+      if (items.length === 0) {
+        event.preventDefault();
+        return;
+      }
+      const firstEl = items[0];
+      const lastEl = items[items.length - 1];
+      const active = document.activeElement;
+      if (event.shiftKey && active === firstEl) {
+        event.preventDefault();
+        lastEl.focus();
+      } else if (!event.shiftKey && active === lastEl) {
+        event.preventDefault();
+        firstEl.focus();
+      }
+    }
+    root.addEventListener("keydown", onKeyDown);
+    return () => {
+      root.removeEventListener("keydown", onKeyDown);
+      previouslyFocused?.focus?.();
+    };
+  }, [enabled]);
+  return ref;
+}
+export {
+  focusCandidates,
+  useFocusScope
+};
+//# sourceMappingURL=focus-scope.js.map

package/dist/primitives/focus-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/primitives/focus-scope.tsx"],"sourcesContent":["\"use client\";\n\nimport * as React from \"react\";\n\n// `tabindex=\"-1\"` opts an element out of Tab order whatever its tag, so the\n// exclusion goes on every branch — otherwise a roving-tabindex grid's parked\n// cells would count as tab stops.\nconst FOCUSABLE = [\n  \"a[href]\",\n  \"button:not([disabled])\",\n  \"textarea:not([disabled])\",\n  \"input:not([disabled])\",\n  \"select:not([disabled])\",\n  \"[tabindex]\",\n]\n  .map(sel => `${sel}:not([tabindex=\"-1\"])`)\n  .join(\",\");\n\n/**\n * Every enabled, Tab-reachable candidate under `root` in DOM (= Tab) order,\n * before the layout-based visibility filter; `tabindex=\"-1\"` is skipped on any\n * tag. For content that is fully visible while it exists (a popover), this is\n * the tab order itself. Internal to the kit.\n */\nexport function focusCandidates(root: HTMLElement): HTMLElement[] {\n  return Array.from(root.querySelectorAll<HTMLElement>(FOCUSABLE));\n}\n\nfunction focusable(root: HTMLElement): HTMLElement[] {\n  return focusCandidates(root).filter(\n    (el) => el.offsetWidth > 0 || el.offsetHeight > 0 || el === document.activeElement,\n  );\n}\n\n/**\n * Traps Tab focus inside the returned ref's subtree and restores focus to the\n * previously-focused element on unmount — the dep-light core of dialogs/menus,\n * replacing `@radix-ui/react-focus-scope`. On mount, focuses the first\n * focusable (or the container itself).\n *\n * Rust dialogs rely on the browser's native focus order within a fixed overlay;\n * see the README \"Limitations\".\n */\nexport function useFocusScope(enabled: boolean): React.RefObject<HTMLDivElement | null> {\n  const ref = React.useRef<HTMLDivElement | null>(null);\n\n  React.useEffect(() => {\n    if (!enabled) return;\n    const root = ref.current;\n    if (!root) return;\n\n    const previouslyFocused = document.activeElement as HTMLElement | null;\n    const first = focusable(root)[0];\n    (first ?? root).focus();\n\n    function onKeyDown(event: KeyboardEvent) {\n      if (event.key !== \"Tab\" || !root) return;\n      const items = focusable(root);\n      if (items.length === 0) {\n        event.preventDefault();\n        return;\n      }\n      const firstEl = items[0]!;\n      const lastEl = items[items.length - 1]!;\n      const active = document.activeElement;\n      if (event.shiftKey && active === firstEl) {\n        event.preventDefault();\n        lastEl.focus();\n      } else if (!event.shiftKey && active === lastEl) {\n        event.preventDefault();\n        firstEl.focus();\n      }\n    }\n\n    root.addEventListener(\"keydown\", onKeyDown);\n    return () => {\n      root.removeEventListener(\"keydown\", onKeyDown);\n      previouslyFocused?.focus?.();\n    };\n  }, [enabled]);\n\n  return ref;\n}\n"],"mappings":";AAEA,YAAY,WAAW;AAKvB,MAAM,YAAY;AAAA,EAChB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EACG,IAAI,SAAO,GAAG,GAAG,uBAAuB,EACxC,KAAK,GAAG;AAQJ,SAAS,gBAAgB,MAAkC;AAChE,SAAO,MAAM,KAAK,KAAK,iBAA8B,SAAS,CAAC;AACjE;AAEA,SAAS,UAAU,MAAkC;AACnD,SAAO,gBAAgB,IAAI,EAAE;AAAA,IAC3B,CAAC,OAAO,GAAG,cAAc,KAAK,GAAG,eAAe,KAAK,OAAO,SAAS;AAAA,EACvE;AACF;AAWO,SAAS,cAAc,SAA0D;AACtF,QAAM,MAAM,MAAM,OAA8B,IAAI;AAEpD,QAAM,UAAU,MAAM;AACpB,QAAI,CAAC,QAAS;AACd,UAAM,OAAO,IAAI;AACjB,QAAI,CAAC,KAAM;AAEX,UAAM,oBAAoB,SAAS;AACnC,UAAM,QAAQ,UAAU,IAAI,EAAE,CAAC;AAC/B,KAAC,SAAS,MAAM,MAAM;AAEtB,aAAS,UAAU,OAAsB;AACvC,UAAI,MAAM,QAAQ,SAAS,CAAC,KAAM;AAClC,YAAM,QAAQ,UAAU,IAAI;AAC5B,UAAI,MAAM,WAAW,GAAG;AACtB,cAAM,eAAe;AACrB;AAAA,MACF;AACA,YAAM,UAAU,MAAM,CAAC;AACvB,YAAM,SAAS,MAAM,MAAM,SAAS,CAAC;AACrC,YAAM,SAAS,SAAS;AACxB,UAAI,MAAM,YAAY,WAAW,SAAS;AACxC,cAAM,eAAe;AACrB,eAAO,MAAM;AAAA,MACf,WAAW,CAAC,MAAM,YAAY,WAAW,QAAQ;AAC/C,cAAM,eAAe;AACrB,gBAAQ,MAAM;AAAA,MAChB;AAAA,IACF;AAEA,SAAK,iBAAiB,WAAW,SAAS;AAC1C,WAAO,MAAM;AACX,WAAK,oBAAoB,WAAW,SAAS;AAC7C,yBAAmB,QAAQ;AAAA,IAC7B;AAAA,EACF,GAAG,CAAC,OAAO,CAAC;AAEZ,SAAO;AACT;","names":[]}

package/dist/primitives/merge-refs.js

@@ -0,0 +1,13 @@
+import * as React from "react";
+function mergeRefs(...refs) {
+  return (node) => {
+    for (const ref of refs) {
+      if (typeof ref === "function") ref(node);
+      else if (ref != null) ref.current = node;
+    }
+  };
+}
+export {
+  mergeRefs
+};
+//# sourceMappingURL=merge-refs.js.map

package/dist/primitives/merge-refs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/primitives/merge-refs.ts"],"sourcesContent":["import * as React from \"react\";\n\n/**\n * Combines several refs into one callback ref so a node can satisfy multiple\n * consumers at once (e.g. an overlay that is both the floating element and the\n * dismissable layer). Used throughout the overlay components.\n */\nexport function mergeRefs<T>(\n  ...refs: Array<React.Ref<T> | undefined>\n): React.RefCallback<T> {\n  return (node) => {\n    for (const ref of refs) {\n      if (typeof ref === \"function\") ref(node);\n      else if (ref != null) (ref as React.MutableRefObject<T | null>).current = node;\n    }\n  };\n}\n"],"mappings":"AAAA,YAAY,WAAW;AAOhB,SAAS,aACX,MACmB;AACtB,SAAO,CAAC,SAAS;AACf,eAAW,OAAO,MAAM;AACtB,UAAI,OAAO,QAAQ,WAAY,KAAI,IAAI;AAAA,eAC9B,OAAO,KAAM,CAAC,IAAyC,UAAU;AAAA,IAC5E;AAAA,EACF;AACF;","names":[]}

package/dist/primitives/portal.js

@@ -0,0 +1,19 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { createPortal } from "react-dom";
+const PortalContext = React.createContext(null);
+function PortalProvider({ container, children }) {
+  return /* @__PURE__ */ jsx(PortalContext.Provider, { value: container, children });
+}
+function Portal({ children, container }) {
+  const provided = React.useContext(PortalContext);
+  if (typeof document === "undefined") return null;
+  const target = container ?? provided ?? document.body;
+  return createPortal(children, target);
+}
+export {
+  Portal,
+  PortalProvider
+};
+//# sourceMappingURL=portal.js.map

package/dist/primitives/portal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/primitives/portal.tsx"],"sourcesContent":["\"use client\";\n\nimport * as React from \"react\";\nimport { createPortal } from \"react-dom\";\n\n/**\n * Renders its children into `container` (default: the nearest\n * {@link PortalProvider}'s, else `document.body`) via `react-dom`'s\n * `createPortal` — the dep-light stand-in for `@radix-ui/react-portal`.\n * SSR-safe: renders nothing until mounted.\n *\n * Rust has no portal counterpart (see the README \"Limitations\"): `ev_lib::uikit`\n * overlays render inline with fixed positioning instead.\n */\nexport interface PortalProps {\n  children: React.ReactNode;\n  container?: Element | null;\n}\n\nconst PortalContext = React.createContext<Element | null>(null);\n\nexport interface PortalProviderProps {\n  /** Where every overlay beneath this provider mounts; `null` falls back to `document.body`. */\n  container: Element | null;\n  children?: React.ReactNode;\n}\n\n/**\n * Re-targets every overlay beneath it (Dialog, Select, Popover, Tooltip, …)\n * into `container`. Tokens are inherited custom properties, so an overlay\n * portaled to `document.body` leaves its `[data-brand]` scope and paints in\n * the root palette; mounted inside the scope, it keeps the brand's.\n */\nexport function PortalProvider({ container, children }: PortalProviderProps) {\n  return <PortalContext.Provider value={container}>{children}</PortalContext.Provider>;\n}\n\nexport function Portal({ children, container }: PortalProps) {\n  const provided = React.useContext(PortalContext);\n  // Render the portal synchronously on the client so a consumer's ref (e.g. a\n  // floating element measured in `useLayoutEffect`) is attached in the same\n  // commit. Overlays only render this when open — i.e. after a client event —\n  // so there is no server render to mismatch.\n  if (typeof document === \"undefined\") return null;\n  const target = container ?? provided ?? document.body;\n  return createPortal(children, target);\n}\n"],"mappings":";AAkCS;AAhCT,YAAY,WAAW;AACvB,SAAS,oBAAoB;AAgB7B,MAAM,gBAAgB,MAAM,cAA8B,IAAI;AAcvD,SAAS,eAAe,EAAE,WAAW,SAAS,GAAwB;AAC3E,SAAO,oBAAC,cAAc,UAAd,EAAuB,OAAO,WAAY,UAAS;AAC7D;AAEO,SAAS,OAAO,EAAE,UAAU,UAAU,GAAgB;AAC3D,QAAM,WAAW,MAAM,WAAW,aAAa;AAK/C,MAAI,OAAO,aAAa,YAAa,QAAO;AAC5C,QAAM,SAAS,aAAa,YAAY,SAAS;AACjD,SAAO,aAAa,UAAU,MAAM;AACtC;","names":[]}

package/dist/primitives/presence.js

@@ -0,0 +1,45 @@
+"use client";
+import * as React from "react";
+import { flushSync } from "react-dom";
+const EXIT_FALLBACK_MS = 1e3;
+function usePresence(present) {
+  const ref = React.useRef(null);
+  const [mounted, setMounted] = React.useState(present);
+  React.useLayoutEffect(() => {
+    if (present) {
+      setMounted(true);
+      return;
+    }
+    const node = ref.current;
+    if (!node) {
+      setMounted(false);
+      return;
+    }
+    const name = getComputedStyle(node).animationName;
+    if (name === "" || name === "none") {
+      setMounted(false);
+      return;
+    }
+    const prevPointerEvents = node.style.pointerEvents;
+    node.style.pointerEvents = "none";
+    const onEnd = (e) => {
+      if (e.target !== node) return;
+      if (e.animationName && !name.includes(e.animationName)) return;
+      flushSync(() => setMounted(false));
+    };
+    node.addEventListener("animationend", onEnd);
+    node.addEventListener("animationcancel", onEnd);
+    const timer = setTimeout(() => setMounted(false), EXIT_FALLBACK_MS);
+    return () => {
+      clearTimeout(timer);
+      node.removeEventListener("animationend", onEnd);
+      node.removeEventListener("animationcancel", onEnd);
+      node.style.pointerEvents = prevPointerEvents;
+    };
+  }, [present]);
+  return { isPresent: present || mounted, ref };
+}
+export {
+  usePresence
+};
+//# sourceMappingURL=presence.js.map

package/dist/primitives/presence.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/primitives/presence.ts"],"sourcesContent":["\"use client\";\n\nimport * as React from \"react\";\nimport { flushSync } from \"react-dom\";\n\n// Safety net for a missed exit `animationend` (display:none ancestor, tab\n// hidden, animations disabled by a stylesheet after the check). Well past the\n// longest exit in tw-animate-css.\nconst EXIT_FALLBACK_MS = 1000;\n\n/**\n * Keeps an overlay mounted through its exit animation. Enter animations\n * (`data-[state=open]:animate-in`) play on mount; once `present` turns false\n * the consumer flips the node to `data-state=\"closed\"` in the same render and\n * the node stays until its exit animation ends (or the fallback timer fires).\n * Re-opening mid-exit just flips the state back; the node is never remounted.\n *\n * The exit was dropped once (5728b40) because closing flickered: tw-animate's\n * `animate-out` runs with `animation-fill-mode: none`, so after `animationend`\n * the node snaps back to full opacity/scale for the frame React needs to\n * process an async unmount. Hence `flushSync` inside the native listener —\n * the unmount commits before the browser paints that frame (Radix Presence\n * does the same). With no animation on the node (jsdom, overlays without an\n * exit class) unmount is immediate, as before. The Rust mirror still does not\n * defer unmount.\n *\n * Pass `ref` to the animated node — the one carrying `data-state`.\n */\nexport function usePresence(present: boolean): {\n  isPresent: boolean;\n  ref: React.RefObject<HTMLElement | null>;\n} {\n  const ref = React.useRef<HTMLElement | null>(null);\n  const [mounted, setMounted] = React.useState(present);\n\n  React.useLayoutEffect(() => {\n    if (present) {\n      setMounted(true);\n      return;\n    }\n    const node = ref.current;\n    if (!node) {\n      setMounted(false);\n      return;\n    }\n    // `data-state=\"closed\"` is already in the DOM, so this resolves to the\n    // exit animation (if any) — reading it forces the style recalc.\n    const name = getComputedStyle(node).animationName;\n    if (name === \"\" || name === \"none\") {\n      setMounted(false);\n      return;\n    }\n    const prevPointerEvents = node.style.pointerEvents;\n    node.style.pointerEvents = \"none\";\n    // Animation events bubble from descendants, and a close mid-enter cancels\n    // the enter keyframe on this very node — only the exit's own end counts.\n    const onEnd = (e: AnimationEvent) => {\n      if (e.target !== node) return;\n      if (e.animationName && !name.includes(e.animationName)) return;\n      flushSync(() => setMounted(false));\n    };\n    node.addEventListener(\"animationend\", onEnd);\n    node.addEventListener(\"animationcancel\", onEnd);\n    const timer = setTimeout(() => setMounted(false), EXIT_FALLBACK_MS);\n    return () => {\n      clearTimeout(timer);\n      node.removeEventListener(\"animationend\", onEnd);\n      node.removeEventListener(\"animationcancel\", onEnd);\n      node.style.pointerEvents = prevPointerEvents;\n    };\n  }, [present]);\n\n  return { isPresent: present || mounted, ref };\n}\n"],"mappings":";AAEA,YAAY,WAAW;AACvB,SAAS,iBAAiB;AAK1B,MAAM,mBAAmB;AAoBlB,SAAS,YAAY,SAG1B;AACA,QAAM,MAAM,MAAM,OAA2B,IAAI;AACjD,QAAM,CAAC,SAAS,UAAU,IAAI,MAAM,SAAS,OAAO;AAEpD,QAAM,gBAAgB,MAAM;AAC1B,QAAI,SAAS;AACX,iBAAW,IAAI;AACf;AAAA,IACF;AACA,UAAM,OAAO,IAAI;AACjB,QAAI,CAAC,MAAM;AACT,iBAAW,KAAK;AAChB;AAAA,IACF;AAGA,UAAM,OAAO,iBAAiB,IAAI,EAAE;AACpC,QAAI,SAAS,MAAM,SAAS,QAAQ;AAClC,iBAAW,KAAK;AAChB;AAAA,IACF;AACA,UAAM,oBAAoB,KAAK,MAAM;AACrC,SAAK,MAAM,gBAAgB;AAG3B,UAAM,QAAQ,CAAC,MAAsB;AACnC,UAAI,EAAE,WAAW,KAAM;AACvB,UAAI,EAAE,iBAAiB,CAAC,KAAK,SAAS,EAAE,aAAa,EAAG;AACxD,gBAAU,MAAM,WAAW,KAAK,CAAC;AAAA,IACnC;AACA,SAAK,iBAAiB,gBAAgB,KAAK;AAC3C,SAAK,iBAAiB,mBAAmB,KAAK;AAC9C,UAAM,QAAQ,WAAW,MAAM,WAAW,KAAK,GAAG,gBAAgB;AAClE,WAAO,MAAM;AACX,mBAAa,KAAK;AAClB,WAAK,oBAAoB,gBAAgB,KAAK;AAC9C,WAAK,oBAAoB,mBAAmB,KAAK;AACjD,WAAK,MAAM,gBAAgB;AAAA,IAC7B;AAAA,EACF,GAAG,CAAC,OAAO,CAAC;AAEZ,SAAO,EAAE,WAAW,WAAW,SAAS,IAAI;AAC9C;","names":[]}

package/dist/primitives/slot.js

@@ -0,0 +1,39 @@
+import * as React from "react";
+import { cn } from "../lib/cn.js";
+const Slot = React.forwardRef(function Slot2({ children, ...slotProps }, forwardedRef) {
+  if (!React.isValidElement(children)) {
+    return React.Children.count(children) > 1 ? React.Children.only(null) : null;
+  }
+  const child = children;
+  const childProps = child.props;
+  const merged = { ...slotProps, ...childProps };
+  for (const key of Object.keys(slotProps)) {
+    const slotValue = slotProps[key];
+    const childValue = childProps[key];
+    if (/^on[A-Z]/.test(key) && typeof slotValue === "function") {
+      merged[key] = typeof childValue === "function" ? (...args) => {
+        childValue(...args);
+        slotValue(...args);
+      } : slotValue;
+    } else if (key === "style") {
+      merged[key] = { ...slotValue, ...childValue };
+    } else if (key === "className") {
+      merged[key] = cn(slotValue, childValue);
+    }
+  }
+  const childRef = child.ref;
+  if (forwardedRef || childRef) merged["ref"] = composeRefs(forwardedRef, childRef);
+  return React.cloneElement(child, merged);
+});
+function composeRefs(...refs) {
+  return (node) => {
+    for (const ref of refs) {
+      if (typeof ref === "function") ref(node);
+      else if (ref != null) ref.current = node;
+    }
+  };
+}
+export {
+  Slot
+};
+//# sourceMappingURL=slot.js.map

package/dist/primitives/slot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/primitives/slot.tsx"],"sourcesContent":["import * as React from \"react\";\nimport { cn } from \"../lib/cn\";\n\n/**\n * Minimal `asChild` mechanism — the dep-light replacement for\n * `@radix-ui/react-slot`. Renders by cloning its single child, merging the\n * Slot's own props onto it: `className` is fused with `cn`, event handlers are\n * chained (child's runs first, then ours), and `style` objects are shallow\n * merged. Refs are composed so both the caller's and the child's ref fire.\n *\n * There is no Rust counterpart: Dioxus composition is expressed with `children`\n * directly, so `asChild` is a TS-only ergonomic.\n */\nexport interface SlotProps extends React.HTMLAttributes<HTMLElement> {\n  children?: React.ReactNode;\n}\n\nexport const Slot = React.forwardRef<HTMLElement, SlotProps>(function Slot(\n  { children, ...slotProps },\n  forwardedRef,\n) {\n  if (!React.isValidElement(children)) {\n    return React.Children.count(children) > 1\n      ? React.Children.only(null)\n      : null;\n  }\n\n  const child = children as React.ReactElement<Record<string, unknown>>;\n  const childProps = child.props;\n\n  const merged: Record<string, unknown> = { ...slotProps, ...childProps };\n\n  for (const key of Object.keys(slotProps)) {\n    const slotValue = (slotProps as Record<string, unknown>)[key];\n    const childValue = childProps[key];\n    if (/^on[A-Z]/.test(key) && typeof slotValue === \"function\") {\n      merged[key] =\n        typeof childValue === \"function\"\n          ? (...args: unknown[]) => {\n              (childValue as (...a: unknown[]) => void)(...args);\n              (slotValue as (...a: unknown[]) => void)(...args);\n            }\n          : slotValue;\n    } else if (key === \"style\") {\n      merged[key] = { ...(slotValue as object), ...(childValue as object) };\n    } else if (key === \"className\") {\n      merged[key] = cn(slotValue as string, childValue as string);\n    }\n  }\n\n  // Only when there is a ref to compose. `Slot` renders inside server\n  // components too (`<Button asChild>` has no \"use client\"), and a function\n  // ref in a Server Component's output fails the render (\"Refs cannot be used\n  // in Server Components\") even when it would call nothing.\n  const childRef = (child as { ref?: React.Ref<unknown> }).ref;\n  if (forwardedRef || childRef) merged[\"ref\"] = composeRefs(forwardedRef, childRef);\n\n  return React.cloneElement(child, merged);\n});\n\nfunction composeRefs<T>(...refs: Array<React.Ref<T> | undefined>): React.RefCallback<T> {\n  return (node) => {\n    for (const ref of refs) {\n      if (typeof ref === \"function\") ref(node);\n      else if (ref != null) (ref as React.MutableRefObject<T | null>).current = node;\n    }\n  };\n}\n"],"mappings":"AAAA,YAAY,WAAW;AACvB,SAAS,UAAU;AAgBZ,MAAM,OAAO,MAAM,WAAmC,SAASA,MACpE,EAAE,UAAU,GAAG,UAAU,GACzB,cACA;AACA,MAAI,CAAC,MAAM,eAAe,QAAQ,GAAG;AACnC,WAAO,MAAM,SAAS,MAAM,QAAQ,IAAI,IACpC,MAAM,SAAS,KAAK,IAAI,IACxB;AAAA,EACN;AAEA,QAAM,QAAQ;AACd,QAAM,aAAa,MAAM;AAEzB,QAAM,SAAkC,EAAE,GAAG,WAAW,GAAG,WAAW;AAEtE,aAAW,OAAO,OAAO,KAAK,SAAS,GAAG;AACxC,UAAM,YAAa,UAAsC,GAAG;AAC5D,UAAM,aAAa,WAAW,GAAG;AACjC,QAAI,WAAW,KAAK,GAAG,KAAK,OAAO,cAAc,YAAY;AAC3D,aAAO,GAAG,IACR,OAAO,eAAe,aAClB,IAAI,SAAoB;AACtB,QAAC,WAAyC,GAAG,IAAI;AACjD,QAAC,UAAwC,GAAG,IAAI;AAAA,MAClD,IACA;AAAA,IACR,WAAW,QAAQ,SAAS;AAC1B,aAAO,GAAG,IAAI,EAAE,GAAI,WAAsB,GAAI,WAAsB;AAAA,IACtE,WAAW,QAAQ,aAAa;AAC9B,aAAO,GAAG,IAAI,GAAG,WAAqB,UAAoB;AAAA,IAC5D;AAAA,EACF;AAMA,QAAM,WAAY,MAAuC;AACzD,MAAI,gBAAgB,SAAU,QAAO,KAAK,IAAI,YAAY,cAAc,QAAQ;AAEhF,SAAO,MAAM,aAAa,OAAO,MAAM;AACzC,CAAC;AAED,SAAS,eAAkB,MAA6D;AACtF,SAAO,CAAC,SAAS;AACf,eAAW,OAAO,MAAM;AACtB,UAAI,OAAO,QAAQ,WAAY,KAAI,IAAI;AAAA,eAC9B,OAAO,KAAM,CAAC,IAAyC,UAAU;AAAA,IAC5E;AAAA,EACF;AACF;","names":["Slot"]}

package/dist/primitives/use-controllable-state.js

@@ -0,0 +1,24 @@
+"use client";
+import * as React from "react";
+function useControllableState(opts) {
+  const { value, defaultValue, onChange } = opts;
+  const isControlled = value !== void 0;
+  const [uncontrolled, setUncontrolled] = React.useState(defaultValue);
+  const current = isControlled ? value : uncontrolled;
+  const onChangeRef = React.useRef(onChange);
+  React.useEffect(() => {
+    onChangeRef.current = onChange;
+  });
+  const setValue = React.useCallback(
+    (next) => {
+      if (!isControlled) setUncontrolled(next);
+      onChangeRef.current?.(next);
+    },
+    [isControlled]
+  );
+  return [current, setValue];
+}
+export {
+  useControllableState
+};
+//# sourceMappingURL=use-controllable-state.js.map

package/dist/primitives/use-controllable-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/primitives/use-controllable-state.ts"],"sourcesContent":["\"use client\";\n\nimport * as React from \"react\";\n\n/**\n * Controlled/uncontrolled state, the dep-light equivalent of Radix's\n * `useControllableState`. When `value` is provided the component is controlled\n * (the hook returns it and routes writes through `onChange`); otherwise it owns\n * an internal `useState` seeded from `defaultValue`.\n *\n * The Rust mirror is `use_controllable_signal` in `ev_lib::uikit`.\n */\nexport function useControllableState<T>(opts: {\n  value?: T | undefined;\n  defaultValue: T;\n  onChange?: ((value: T) => void) | undefined;\n}): [T, (next: T) => void] {\n  const { value, defaultValue, onChange } = opts;\n  const isControlled = value !== undefined;\n  const [uncontrolled, setUncontrolled] = React.useState<T>(defaultValue);\n\n  const current = isControlled ? value : uncontrolled;\n\n  const onChangeRef = React.useRef(onChange);\n  React.useEffect(() => {\n    onChangeRef.current = onChange;\n  });\n\n  const setValue = React.useCallback(\n    (next: T) => {\n      if (!isControlled) setUncontrolled(next);\n      onChangeRef.current?.(next);\n    },\n    [isControlled],\n  );\n\n  return [current, setValue];\n}\n"],"mappings":";AAEA,YAAY,WAAW;AAUhB,SAAS,qBAAwB,MAIb;AACzB,QAAM,EAAE,OAAO,cAAc,SAAS,IAAI;AAC1C,QAAM,eAAe,UAAU;AAC/B,QAAM,CAAC,cAAc,eAAe,IAAI,MAAM,SAAY,YAAY;AAEtE,QAAM,UAAU,eAAe,QAAQ;AAEvC,QAAM,cAAc,MAAM,OAAO,QAAQ;AACzC,QAAM,UAAU,MAAM;AACpB,gBAAY,UAAU;AAAA,EACxB,CAAC;AAED,QAAM,WAAW,MAAM;AAAA,IACrB,CAAC,SAAY;AACX,UAAI,CAAC,aAAc,iBAAgB,IAAI;AACvC,kBAAY,UAAU,IAAI;AAAA,IAC5B;AAAA,IACA,CAAC,YAAY;AAAA,EACf;AAEA,SAAO,CAAC,SAAS,QAAQ;AAC3B;","names":[]}

package/dist/primitives/use-floating.js

@@ -0,0 +1,128 @@
+"use client";
+import * as React from "react";
+const ABSOLUTE = Object.freeze({ position: "absolute", top: 0, left: 0 });
+const POSITIONED = /* @__PURE__ */ new Set(["relative", "absolute", "fixed", "sticky"]);
+function toContainingBlock(floating, x, y) {
+  const parent = floating.offsetParent;
+  const doc = floating.ownerDocument;
+  const root = parent === doc.body || parent === doc.documentElement || parent === null;
+  const positioned = parent instanceof HTMLElement && (!root || POSITIONED.has(doc.defaultView?.getComputedStyle(parent).position ?? ""));
+  if (!positioned) {
+    const win = doc.defaultView;
+    return { x: x + (win?.scrollX ?? 0), y: y + (win?.scrollY ?? 0), root: true };
+  }
+  const p = parent.getBoundingClientRect();
+  return {
+    x: x - p.left - parent.clientLeft + parent.scrollLeft,
+    y: y - p.top - parent.clientTop + parent.scrollTop,
+    root: false
+  };
+}
+function layoutSize(el) {
+  return { width: el.offsetWidth, height: el.offsetHeight };
+}
+function viewport() {
+  const el = document.documentElement;
+  return {
+    vw: el.clientWidth || window.innerWidth,
+    vh: el.clientHeight || window.innerHeight
+  };
+}
+function useFloating(opts) {
+  const { anchorRef, open, side = "bottom", align = "center", offset = 4 } = opts;
+  const floatingRef = React.useRef(null);
+  const [placedSide, setPlacedSide] = React.useState(side);
+  const placement = React.useRef({
+    side,
+    shiftX: 0,
+    shiftY: 0
+  });
+  React.useLayoutEffect(() => {
+    if (!open) return;
+    function ideal(a, f, placed) {
+      let top = 0;
+      let left = 0;
+      const vertical = placed === "top" || placed === "bottom";
+      if (placed === "bottom") top = a.bottom + offset;
+      else if (placed === "top") top = a.top - offset - f.height;
+      else if (placed === "right") left = a.right + offset;
+      else left = a.left - offset - f.width;
+      if (vertical) {
+        if (align === "start") left = a.left;
+        else if (align === "end") left = a.right - f.width;
+        else left = a.left + a.width / 2 - f.width / 2;
+      } else {
+        if (align === "start") top = a.top;
+        else if (align === "end") top = a.bottom - f.height;
+        else top = a.top + a.height / 2 - f.height / 2;
+      }
+      return { top, left };
+    }
+    function write(floating, f, top, left, contain) {
+      const p = toContainingBlock(floating, left, top);
+      let { x, y } = p;
+      if (contain && p.root) {
+        const icbWidth = floating.ownerDocument.documentElement.clientWidth || window.innerWidth;
+        x = Math.max(0, Math.min(x, icbWidth - f.width));
+        y = Math.max(0, y);
+      }
+      floating.style.translate = `${Math.round(x)}px ${Math.round(y)}px`;
+    }
+    function place() {
+      const anchor = anchorRef.current;
+      const floating = floatingRef.current;
+      if (!anchor || !floating) return;
+      const a = anchor.getBoundingClientRect();
+      const f = layoutSize(floating);
+      const { vw, vh } = viewport();
+      let placed = side;
+      if (side === "bottom" && a.bottom + offset + f.height > vh && a.top - offset - f.height > 0)
+        placed = "top";
+      else if (side === "top" && a.top - offset - f.height < 0 && a.bottom + offset + f.height < vh)
+        placed = "bottom";
+      else if (side === "right" && a.right + offset + f.width > vw && a.left - offset - f.width > 0)
+        placed = "left";
+      else if (side === "left" && a.left - offset - f.width < 0 && a.right + offset + f.width < vw)
+        placed = "right";
+      const { top, left } = ideal(a, f, placed);
+      const clampedLeft = Math.max(offset, Math.min(left, vw - f.width - offset));
+      const clampedTop = Math.max(offset, Math.min(top, vh - f.height - offset));
+      placement.current = {
+        side: placed,
+        shiftX: clampedLeft - left,
+        shiftY: clampedTop - top
+      };
+      write(floating, f, clampedTop, clampedLeft, false);
+      setPlacedSide((prev) => prev === placed ? prev : placed);
+    }
+    function sync() {
+      const anchor = anchorRef.current;
+      const floating = floatingRef.current;
+      if (!anchor || !floating) return;
+      const a = anchor.getBoundingClientRect();
+      const f = layoutSize(floating);
+      const { side: placed, shiftX, shiftY } = placement.current;
+      const { top, left } = ideal(a, f, placed);
+      write(floating, f, top + shiftY, left + shiftX, true);
+    }
+    place();
+    window.addEventListener("scroll", sync, true);
+    window.addEventListener("resize", place);
+    let observer;
+    if (typeof ResizeObserver !== "undefined") {
+      observer = new ResizeObserver(place);
+      if (anchorRef.current) observer.observe(anchorRef.current);
+      if (floatingRef.current) observer.observe(floatingRef.current);
+    }
+    return () => {
+      window.removeEventListener("scroll", sync, true);
+      window.removeEventListener("resize", place);
+      observer?.disconnect();
+    };
+  }, [open, side, align, offset, anchorRef]);
+  return { floatingRef, style: ABSOLUTE, side: placedSide, align };
+}
+export {
+  useFloating
+};
+//# sourceMappingURL=use-floating.js.map