@stridge/noctis 1.0.0-beta.0

package/dist/components/otp-field/otp-field.props.js

@@ -0,0 +1,43 @@
+import { OTP_FIELD_SLOTS } from "./otp-field.slots.js";
+//#region src/components/otp-field/otp-field.props.ts
+/**
+* The D12 unified variant contract for OtpField — each compound part exposes a `props(...)` builder
+* returning a **spreadable props object** of the form `{ "data-slot": "noctis-otp-field-<part>",
+* ...dataAttrs }`, derived from the part's variant/state inputs. Under the single-`data-slot` anchor
+* model the `data-slot` is the only styling hook needed — `otp-field.css` keys every rule off it — so
+* spreading a part's `props()` onto a *foreign* element styles it as that part:
+*
+*     <input {...OtpField.Input.props({ invalid: true })} />
+*     // → <input data-slot="noctis-otp-field-input" data-invalid="">
+*
+* The escape hatch carries no className (styling is attribute-driven); an optional `className`
+* passthrough is accepted and forwarded verbatim.
+*/
+/** Stamp a boolean state as a bare data-attribute: present (`""`) when on, absent (`undefined`) when off. */
+const flag = (on) => on ? "" : void 0;
+const withClassName = (bag, className) => className === void 0 ? bag : {
+	...bag,
+	className
+};
+/** Root prop bag: `data-slot` plus the `data-size` the descendant cell rules read. */
+function rootProps({ size = "md", className } = {}) {
+	return withClassName({
+		"data-slot": OTP_FIELD_SLOTS.root,
+		"data-size": size
+	}, className);
+}
+/** Cell prop bag: slot anchor plus the `data-filled`/`data-disabled`/`data-invalid` state. */
+function inputProps({ filled, disabled, invalid, className } = {}) {
+	return withClassName({
+		"data-slot": OTP_FIELD_SLOTS.input,
+		"data-filled": flag(filled),
+		"data-disabled": flag(disabled),
+		"data-invalid": flag(invalid)
+	}, className);
+}
+/** Separator prop bag: just the slot anchor the divider rule keys off (Base UI stamps `data-orientation` itself). */
+function separatorProps({ className } = {}) {
+	return withClassName({ "data-slot": OTP_FIELD_SLOTS.separator }, className);
+}
+//#endregion
+export { inputProps, rootProps, separatorProps };

package/dist/components/otp-field/otp-field.slots.d.ts

@@ -0,0 +1,28 @@
+//#region src/components/otp-field/otp-field.slots.d.ts
+/**
+ * The `data-*` hooks `OtpField` stamps on its parts, for host-side styling and tests. Slot values
+ * mark each rendered element; the state attributes are emitted by Base UI's OTP Field — pair a slot
+ * with a state to target, say, only a filled or invalid cell.
+ */
+declare enum OtpFieldDataAttributes {
+  /** The root OTP-field element. */
+  slot = "data-slot",
+  /** Present on the root when every slot is filled. */
+  complete = "data-complete",
+  /** Present on a cell that contains a character, and on the root when any cell is filled. */
+  filled = "data-filled",
+  /** Present when the field is disabled. */
+  disabled = "data-disabled",
+  /** Present when the field is read-only. */
+  readonly = "data-readonly",
+  /** Present when the field is required. */
+  required = "data-required",
+  /** Present on the root when one of the cells is focused. */
+  focused = "data-focused",
+  /** Present when the field is in a valid state (wrapped in `Field.Root`). */
+  valid = "data-valid",
+  /** Present when the field is in an invalid state (wrapped in `Field.Root`). */
+  invalid = "data-invalid"
+}
+//#endregion
+export { OtpFieldDataAttributes };

package/dist/components/otp-field/otp-field.slots.js

@@ -0,0 +1,39 @@
+//#region src/components/otp-field/otp-field.slots.ts
+/**
+* The slot vocabulary every `OtpField` part stamps as its `data-slot`. The authored source the
+* orchestration file reads from, kebab-cased `{component}-{part}`; SLOTS.md still generates from the
+* token-graph declarations.
+*/
+const OTP_FIELD_SLOTS = {
+	root: "noctis-otp-field",
+	input: "noctis-otp-field-input",
+	separator: "noctis-otp-field-separator"
+};
+/**
+* The `data-*` hooks `OtpField` stamps on its parts, for host-side styling and tests. Slot values
+* mark each rendered element; the state attributes are emitted by Base UI's OTP Field — pair a slot
+* with a state to target, say, only a filled or invalid cell.
+*/
+let OtpFieldDataAttributes = /* @__PURE__ */ function(OtpFieldDataAttributes) {
+	/** The root OTP-field element. */
+	OtpFieldDataAttributes["slot"] = "data-slot";
+	/** Present on the root when every slot is filled. */
+	OtpFieldDataAttributes["complete"] = "data-complete";
+	/** Present on a cell that contains a character, and on the root when any cell is filled. */
+	OtpFieldDataAttributes["filled"] = "data-filled";
+	/** Present when the field is disabled. */
+	OtpFieldDataAttributes["disabled"] = "data-disabled";
+	/** Present when the field is read-only. */
+	OtpFieldDataAttributes["readonly"] = "data-readonly";
+	/** Present when the field is required. */
+	OtpFieldDataAttributes["required"] = "data-required";
+	/** Present on the root when one of the cells is focused. */
+	OtpFieldDataAttributes["focused"] = "data-focused";
+	/** Present when the field is in a valid state (wrapped in `Field.Root`). */
+	OtpFieldDataAttributes["valid"] = "data-valid";
+	/** Present when the field is in an invalid state (wrapped in `Field.Root`). */
+	OtpFieldDataAttributes["invalid"] = "data-invalid";
+	return OtpFieldDataAttributes;
+}({});
+//#endregion
+export { OTP_FIELD_SLOTS, OtpFieldDataAttributes };

package/dist/components/popover/index.d.ts

@@ -0,0 +1,2 @@
+import { Popover } from "./popover.js";
+import { PopoverDataAttributes } from "./popover.slots.js";

package/dist/components/popover/popover.d.ts

@@ -0,0 +1,192 @@
+import { popover_d_exports } from "../../primitives/popover.js";
+import { PopoverPartProps, closeProps, descriptionProps, popupProps, titleProps, triggerProps } from "./popover.props.js";
+import { ReactElement } from "react";
+
+//#region src/components/popover/popover.d.ts
+/**
+ * Owns the open state and shares it with the trigger and popup. Wraps Base UI's Popover. Non-modal by
+ * default — the page stays interactive while the popover is open; an outside click or `Escape` closes
+ * it and focus returns to the trigger. Pass `modal` for a focus-trapped, scroll-locked popover.
+ */
+declare function PopoverRoot(props: Popover.Root.Props): ReactElement;
+/**
+ * The control that opens the popover. Style it yourself, or compose a `Button` through `render` — e.g.
+ * `<Popover.Trigger render={<Button variant="secondary">Filters</Button>} />`.
+ */
+declare function PopoverTrigger(props: Popover.Trigger.Props): ReactElement;
+/**
+ * Moves the popup to a portal at the end of `<body>`.
+ */
+declare function PopoverPortal(props: Popover.Portal.Props): ReactElement;
+/**
+ * The floating popup surface — portaled, elevated, and animated — holding the title, description, and
+ * any content. Opens below the trigger, aligned to its start, and is collision-aware: it flips to the
+ * opposite side and stays clear of the viewport edges. Renders through `<Surface elevation="menu">` so
+ * it re-derives the anchored-overlay scope (shared with menu) and paints its base; this file styles
+ * only the popover's own slots, never Surface.
+ *
+ * It caps at the collision-aware `--available-height` and scrolls its inner `viewport` past that — a
+ * popover taller than the screen never clips. The `viewport` carries the content padding/gap so the
+ * scrollbar sits flush at the popup edge.
+ *
+ * Provide the `<Popover.Portal>` and `<Popover.Positioner>` yourself for full control, or use this
+ * `Popup` directly — it portals and positions itself with sensible defaults.
+ */
+declare function PopoverPopup({
+  side,
+  align,
+  sideOffset,
+  alignOffset,
+  collisionPadding,
+  anchor,
+  className,
+  style,
+  children,
+  ...props
+}: Popover.Popup.Props): ReactElement;
+/**
+ * Positions the popup against the trigger — collision-aware, flipping and shifting to stay on screen.
+ * Reach for it (with `Popover.Portal`) when you need to wrap the popup in your own positioning
+ * container; the common case is handled by `Popover.Popup` directly.
+ */
+declare function PopoverPositioner({
+  className,
+  ...props
+}: Popover.Positioner.Props): ReactElement;
+/**
+ * The accessible name of the popover, linked to the popup via `aria-labelledby`. Renders an `<h2>`.
+ */
+declare function PopoverTitle({
+  className,
+  ...props
+}: Popover.Title.Props): ReactElement;
+/**
+ * Supporting copy under the title, linked to the popup via `aria-describedby`. Renders a `<p>`.
+ */
+declare function PopoverDescription({
+  className,
+  ...props
+}: Popover.Description.Props): ReactElement;
+/**
+ * Closes the popover. Renders a bare button and carries no styling of its own, so it composes with any
+ * Noctis `Button` through `render`. Give it an `aria-label` (or visible text) for the accessible name.
+ */
+declare function PopoverClose({
+  className,
+  ...props
+}: Popover.Close.Props): ReactElement;
+/**
+ * A popover: a `Trigger` opens a floating, elevated panel anchored to it. Built on Base UI's Popover
+ * for collision-aware positioning, managed focus (focus moves into the popup and returns to the
+ * trigger on close), and `Escape`/outside-click dismissal, and decoupled from any particular trigger —
+ * pass your own (commonly a `Button` via `render`).
+ *
+ * Compose from parts: `Popover.Root` owns the open state, `Popover.Trigger` opens it, and
+ * `Popover.Popup` is the floating panel — it portals and positions itself, holding an optional
+ * `Title` and `Description` plus any content and a `Close`. For full control over the portal and
+ * positioning, drop a `Popover.Portal` + `Popover.Positioner` around the popup yourself. Noctis
+ * popovers are flush against their anchor — there is no arrow/caret part.
+ *
+ * Styling is precompiled in `popover.css`, keyed off each part's prefixed `data-slot`. Each part also
+ * carries the D12 `props()` escape hatch via `Object.assign` (e.g. `Popover.Title.props()`), returning
+ * a spreadable `{ "data-slot": "noctis-popover-<part>", ... }` bag for a foreign element a
+ * `<Popover.*>` can't wrap.
+ *
+ * The runtime compound is a plain object (kept tree-shakeable); per-part prop and state types are
+ * exposed through the matching `Popover` namespace — e.g. `Popover.Popup.Props`.
+ */
+declare const Popover: {
+  Root: typeof PopoverRoot;
+  Trigger: typeof PopoverTrigger & {
+    props: typeof triggerProps;
+  };
+  Portal: typeof PopoverPortal;
+  Positioner: typeof PopoverPositioner;
+  Popup: typeof PopoverPopup & {
+    props: typeof popupProps;
+  };
+  Title: typeof PopoverTitle & {
+    props: typeof titleProps;
+  };
+  Description: typeof PopoverDescription & {
+    props: typeof descriptionProps;
+  };
+  Close: typeof PopoverClose & {
+    props: typeof closeProps;
+  };
+};
+/**
+ * Per-part prop and state types, mirroring Base UI's `Component.Part.Props` convention. Types-only —
+ * it emits no runtime code and merges with the `Popover` object above, so `Popover.Popup` is the
+ * component value while `Popover.Popup.Props` is its prop type.
+ */
+declare namespace Popover {
+  /** The spreadable data-attribute prop bag every `Popover.*.props()` returns (D12). */
+  type PartProps = PopoverPartProps;
+  namespace Root {
+    type Props = popover_d_exports.Popover.Root.Props;
+    type State = popover_d_exports.Popover.Root.State;
+  }
+  namespace Trigger {
+    type Props = popover_d_exports.Popover.Trigger.Props;
+    type State = popover_d_exports.Popover.Trigger.State;
+  }
+  namespace Portal {
+    type Props = popover_d_exports.Popover.Portal.Props;
+  }
+  namespace Positioner {
+    type Props = popover_d_exports.Popover.Positioner.Props;
+    type State = popover_d_exports.Popover.Positioner.State;
+  }
+  namespace Popup {
+    type Props = popover_d_exports.Popover.Popup.Props & {
+      /**
+       * Which side of the anchor to open on. Collision-aware — flips to the opposite side at the
+       * viewport edge.
+       * @default "bottom"
+       */
+      side?: popover_d_exports.Popover.Positioner.Props["side"];
+      /**
+       * Alignment along that side. Direction-aware — `start`/`end` flip under RTL.
+       * @default "start"
+       */
+      align?: popover_d_exports.Popover.Positioner.Props["align"];
+      /**
+       * Gap from the anchor, in px.
+       * @default 6
+       */
+      sideOffset?: number;
+      /**
+       * Shift along the alignment axis, in px.
+       * @default 0
+       */
+      alignOffset?: number;
+      /**
+       * Minimum space kept from the viewport edge when avoiding collisions, in px.
+       * @default 8
+       */
+      collisionPadding?: popover_d_exports.Popover.Positioner.Props["collisionPadding"];
+      /**
+       * The element to anchor and position against. Defaults to the `Popover.Trigger`; pass an
+       * element, a ref, or a `() => Element | null` getter to anchor a triggerless, fully
+       * controlled popover to an arbitrary element (e.g. a row affordance or a canvas node).
+       */
+      anchor?: popover_d_exports.Popover.Positioner.Props["anchor"];
+    };
+    type State = popover_d_exports.Popover.Popup.State;
+  }
+  namespace Title {
+    type Props = popover_d_exports.Popover.Title.Props;
+    type State = popover_d_exports.Popover.Title.State;
+  }
+  namespace Description {
+    type Props = popover_d_exports.Popover.Description.Props;
+    type State = popover_d_exports.Popover.Description.State;
+  }
+  namespace Close {
+    type Props = popover_d_exports.Popover.Close.Props;
+    type State = popover_d_exports.Popover.Close.State;
+  }
+}
+//#endregion
+export { Popover };

package/dist/components/popover/popover.js

@@ -0,0 +1,152 @@
+"use client";
+import { Surface } from "../surface/surface.js";
+import { popover_exports } from "../../primitives/popover.js";
+import { POPOVER_SLOTS } from "./popover.slots.js";
+import { closeProps, descriptionProps, popupProps, titleProps, triggerProps } from "./popover.props.js";
+import clsx$1 from "clsx";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/popover/popover.tsx
+/**
+* Owns the open state and shares it with the trigger and popup. Wraps Base UI's Popover. Non-modal by
+* default — the page stays interactive while the popover is open; an outside click or `Escape` closes
+* it and focus returns to the trigger. Pass `modal` for a focus-trapped, scroll-locked popover.
+*/
+function PopoverRoot(props) {
+	return /* @__PURE__ */ jsx(popover_exports.Popover.Root, { ...props });
+}
+/**
+* The control that opens the popover. Style it yourself, or compose a `Button` through `render` — e.g.
+* `<Popover.Trigger render={<Button variant="secondary">Filters</Button>} />`.
+*/
+function PopoverTrigger(props) {
+	return /* @__PURE__ */ jsx(popover_exports.Popover.Trigger, {
+		"data-slot": POPOVER_SLOTS.trigger,
+		...props
+	});
+}
+/**
+* Moves the popup to a portal at the end of `<body>`.
+*/
+function PopoverPortal(props) {
+	return /* @__PURE__ */ jsx(popover_exports.Popover.Portal, { ...props });
+}
+/**
+* The floating popup surface — portaled, elevated, and animated — holding the title, description, and
+* any content. Opens below the trigger, aligned to its start, and is collision-aware: it flips to the
+* opposite side and stays clear of the viewport edges. Renders through `<Surface elevation="menu">` so
+* it re-derives the anchored-overlay scope (shared with menu) and paints its base; this file styles
+* only the popover's own slots, never Surface.
+*
+* It caps at the collision-aware `--available-height` and scrolls its inner `viewport` past that — a
+* popover taller than the screen never clips. The `viewport` carries the content padding/gap so the
+* scrollbar sits flush at the popup edge.
+*
+* Provide the `<Popover.Portal>` and `<Popover.Positioner>` yourself for full control, or use this
+* `Popup` directly — it portals and positions itself with sensible defaults.
+*/
+function PopoverPopup({ side = "bottom", align = "start", sideOffset = 6, alignOffset = 0, collisionPadding = 8, anchor, className, style, children, ...props }) {
+	return /* @__PURE__ */ jsx(popover_exports.Popover.Portal, { children: /* @__PURE__ */ jsx(popover_exports.Popover.Positioner, {
+		anchor,
+		side,
+		align,
+		sideOffset,
+		alignOffset,
+		collisionPadding,
+		"data-slot": POPOVER_SLOTS.positioner,
+		children: /* @__PURE__ */ jsx(popover_exports.Popover.Popup, {
+			"data-slot": POPOVER_SLOTS.popup,
+			render: /* @__PURE__ */ jsx(Surface, {
+				elevation: "menu",
+				bordered: true,
+				shadow: "popover"
+			}),
+			style: {
+				transformOrigin: "var(--transform-origin)",
+				maxHeight: "var(--available-height)",
+				...style
+			},
+			className: clsx$1(className),
+			...props,
+			children: /* @__PURE__ */ jsx("div", {
+				"data-slot": POPOVER_SLOTS.viewport,
+				"data-custom-scrollbar": true,
+				children
+			})
+		})
+	}) });
+}
+/**
+* Positions the popup against the trigger — collision-aware, flipping and shifting to stay on screen.
+* Reach for it (with `Popover.Portal`) when you need to wrap the popup in your own positioning
+* container; the common case is handled by `Popover.Popup` directly.
+*/
+function PopoverPositioner({ className, ...props }) {
+	return /* @__PURE__ */ jsx(popover_exports.Popover.Positioner, {
+		"data-slot": POPOVER_SLOTS.positioner,
+		className: clsx$1(className),
+		...props
+	});
+}
+/**
+* The accessible name of the popover, linked to the popup via `aria-labelledby`. Renders an `<h2>`.
+*/
+function PopoverTitle({ className, ...props }) {
+	return /* @__PURE__ */ jsx(popover_exports.Popover.Title, {
+		"data-slot": POPOVER_SLOTS.title,
+		className: clsx$1(className),
+		...props
+	});
+}
+/**
+* Supporting copy under the title, linked to the popup via `aria-describedby`. Renders a `<p>`.
+*/
+function PopoverDescription({ className, ...props }) {
+	return /* @__PURE__ */ jsx(popover_exports.Popover.Description, {
+		"data-slot": POPOVER_SLOTS.description,
+		className: clsx$1(className),
+		...props
+	});
+}
+/**
+* Closes the popover. Renders a bare button and carries no styling of its own, so it composes with any
+* Noctis `Button` through `render`. Give it an `aria-label` (or visible text) for the accessible name.
+*/
+function PopoverClose({ className, ...props }) {
+	return /* @__PURE__ */ jsx(popover_exports.Popover.Close, {
+		"data-slot": POPOVER_SLOTS.close,
+		className: clsx$1(className),
+		...props
+	});
+}
+/**
+* A popover: a `Trigger` opens a floating, elevated panel anchored to it. Built on Base UI's Popover
+* for collision-aware positioning, managed focus (focus moves into the popup and returns to the
+* trigger on close), and `Escape`/outside-click dismissal, and decoupled from any particular trigger —
+* pass your own (commonly a `Button` via `render`).
+*
+* Compose from parts: `Popover.Root` owns the open state, `Popover.Trigger` opens it, and
+* `Popover.Popup` is the floating panel — it portals and positions itself, holding an optional
+* `Title` and `Description` plus any content and a `Close`. For full control over the portal and
+* positioning, drop a `Popover.Portal` + `Popover.Positioner` around the popup yourself. Noctis
+* popovers are flush against their anchor — there is no arrow/caret part.
+*
+* Styling is precompiled in `popover.css`, keyed off each part's prefixed `data-slot`. Each part also
+* carries the D12 `props()` escape hatch via `Object.assign` (e.g. `Popover.Title.props()`), returning
+* a spreadable `{ "data-slot": "noctis-popover-<part>", ... }` bag for a foreign element a
+* `<Popover.*>` can't wrap.
+*
+* The runtime compound is a plain object (kept tree-shakeable); per-part prop and state types are
+* exposed through the matching `Popover` namespace — e.g. `Popover.Popup.Props`.
+*/
+const Popover = {
+	Root: PopoverRoot,
+	Trigger: Object.assign(PopoverTrigger, { props: triggerProps }),
+	Portal: PopoverPortal,
+	Positioner: PopoverPositioner,
+	Popup: Object.assign(PopoverPopup, { props: popupProps }),
+	Title: Object.assign(PopoverTitle, { props: titleProps }),
+	Description: Object.assign(PopoverDescription, { props: descriptionProps }),
+	Close: Object.assign(PopoverClose, { props: closeProps })
+};
+//#endregion
+export { Popover };

package/dist/components/popover/popover.props.d.ts

@@ -0,0 +1,34 @@
+//#region src/components/popover/popover.props.d.ts
+/** A spreadable data-attribute prop bag — the shape every `Popover.*.props()` returns. */
+type PopoverPartProps = {
+  /** The slot value the matching `popover.css` rules anchor on. */"data-slot": string; /** Forwarded verbatim — styling is attribute-driven, so this is an optional consumer passthrough. */
+  className?: string; /** A data-attribute present (empty string) or absent (`undefined`); never `false`. */
+  [attr: `data-${string}`]: string | undefined;
+};
+/** Common shape: every part's `.props()` accepts an optional `className` passthrough. */
+interface PopoverPropsArgs {
+  /** Forwarded verbatim onto the returned prop bag. */
+  className?: string;
+}
+/** Trigger prop bag: just the slot anchor. */
+declare function triggerProps({
+  className
+}?: PopoverPropsArgs): PopoverPartProps;
+/** Popup prop bag: just the slot anchor (the popup surface paint is owned by the composed Surface). */
+declare function popupProps({
+  className
+}?: PopoverPropsArgs): PopoverPartProps;
+/** Title prop bag: just the slot anchor. */
+declare function titleProps({
+  className
+}?: PopoverPropsArgs): PopoverPartProps;
+/** Description prop bag: just the slot anchor. */
+declare function descriptionProps({
+  className
+}?: PopoverPropsArgs): PopoverPartProps;
+/** Close prop bag: just the slot anchor. */
+declare function closeProps({
+  className
+}?: PopoverPropsArgs): PopoverPartProps;
+//#endregion
+export { PopoverPartProps, closeProps, descriptionProps, popupProps, titleProps, triggerProps };

package/dist/components/popover/popover.props.js

@@ -0,0 +1,44 @@
+import { POPOVER_SLOTS } from "./popover.slots.js";
+//#region src/components/popover/popover.props.ts
+/**
+* The D12 unified variant contract for Popover — a per-part set of `props(...)` builders that each
+* return a **spreadable props object** of the form `{ "data-slot": "noctis-popover-<part>", ... }`,
+* derived from the part's inputs.
+*
+* Under the single-`data-slot` anchor model the `data-slot` is the only styling hook needed —
+* `popover.css` keys every rule off it — so spreading a part's `props()` onto a *foreign* element
+* styles it as that part:
+*
+*     <h2 {...Popover.Title.props()}>Filters</h2>
+*     // → <h2 data-slot="noctis-popover-title">
+*
+* The escape hatch carries no className (styling is attribute-driven); an optional `className`
+* passthrough is accepted and forwarded verbatim. The same mapping is emitted as data from the token
+* graph (`generated/declarations.json`) so non-React / agent consumers can hand-write the markup.
+*/
+const withClassName = (bag, className) => className === void 0 ? bag : {
+	...bag,
+	className
+};
+/** Trigger prop bag: just the slot anchor. */
+function triggerProps({ className } = {}) {
+	return withClassName({ "data-slot": POPOVER_SLOTS.trigger }, className);
+}
+/** Popup prop bag: just the slot anchor (the popup surface paint is owned by the composed Surface). */
+function popupProps({ className } = {}) {
+	return withClassName({ "data-slot": POPOVER_SLOTS.popup }, className);
+}
+/** Title prop bag: just the slot anchor. */
+function titleProps({ className } = {}) {
+	return withClassName({ "data-slot": POPOVER_SLOTS.title }, className);
+}
+/** Description prop bag: just the slot anchor. */
+function descriptionProps({ className } = {}) {
+	return withClassName({ "data-slot": POPOVER_SLOTS.description }, className);
+}
+/** Close prop bag: just the slot anchor. */
+function closeProps({ className } = {}) {
+	return withClassName({ "data-slot": POPOVER_SLOTS.close }, className);
+}
+//#endregion
+export { closeProps, descriptionProps, popupProps, titleProps, triggerProps };

package/dist/components/popover/popover.slots.d.ts

@@ -0,0 +1,22 @@
+//#region src/components/popover/popover.slots.d.ts
+/**
+ * The `data-*` hooks `Popover` stamps on its parts, for host-side styling and tests. Slot values mark
+ * each rendered element; the state attributes are emitted by Base UI's Popover — pair a slot with a
+ * state to target, say, the trigger only while its popover is open, or the popup during its transition.
+ */
+declare enum PopoverDataAttributes {
+  /** The trigger element. */
+  trigger = "data-slot",
+  /** Present on the trigger while its popover is open. */
+  popupOpen = "data-popup-open",
+  /** The side of the anchor the popup actually rendered on (`bottom`, `top`, `inline-start`, …). */
+  side = "data-side",
+  /** Present on the popup for the first frame after mount — the transition's start state. */
+  startingStyle = "data-starting-style",
+  /** Present on the popup while it transitions out before unmounting. */
+  endingStyle = "data-ending-style",
+  /** Present on the popup when the change should not animate (keyboard open, dismissal). */
+  instant = "data-instant"
+}
+//#endregion
+export { PopoverDataAttributes };

package/dist/components/popover/popover.slots.js

@@ -0,0 +1,42 @@
+//#region src/components/popover/popover.slots.ts
+/**
+* The slot vocabulary every `Popover` part stamps as its `data-slot`. The authored source the
+* orchestration file reads from, prefixed `noctis-popover-{part}` (the precompiled `popover.css` keys
+* every rule off these anchors); SLOTS.md still generates from the token-graph declaration.
+*
+* `positioner` is a styling-only anchor (the z-index wrapper around the portalled popup) — it carries
+* no token mint, so it lives here but not in the token-graph anatomy. `viewport` is the scrollable
+* inner region the orchestration file wraps the popup's children in (the family overflow idiom): it is
+* declared anatomy but reuses the popup's own padding/gap mints, so it mints nothing of its own.
+*/
+const POPOVER_SLOTS = {
+	trigger: "noctis-popover-trigger",
+	positioner: "noctis-popover-positioner",
+	popup: "noctis-popover-popup",
+	viewport: "noctis-popover-viewport",
+	title: "noctis-popover-title",
+	description: "noctis-popover-description",
+	close: "noctis-popover-close"
+};
+/**
+* The `data-*` hooks `Popover` stamps on its parts, for host-side styling and tests. Slot values mark
+* each rendered element; the state attributes are emitted by Base UI's Popover — pair a slot with a
+* state to target, say, the trigger only while its popover is open, or the popup during its transition.
+*/
+let PopoverDataAttributes = /* @__PURE__ */ function(PopoverDataAttributes) {
+	/** The trigger element. */
+	PopoverDataAttributes["trigger"] = "data-slot";
+	/** Present on the trigger while its popover is open. */
+	PopoverDataAttributes["popupOpen"] = "data-popup-open";
+	/** The side of the anchor the popup actually rendered on (`bottom`, `top`, `inline-start`, …). */
+	PopoverDataAttributes["side"] = "data-side";
+	/** Present on the popup for the first frame after mount — the transition's start state. */
+	PopoverDataAttributes["startingStyle"] = "data-starting-style";
+	/** Present on the popup while it transitions out before unmounting. */
+	PopoverDataAttributes["endingStyle"] = "data-ending-style";
+	/** Present on the popup when the change should not animate (keyboard open, dismissal). */
+	PopoverDataAttributes["instant"] = "data-instant";
+	return PopoverDataAttributes;
+}({});
+//#endregion
+export { POPOVER_SLOTS, PopoverDataAttributes };

package/dist/components/preview-card/index.d.ts

@@ -0,0 +1,2 @@
+import { PreviewCard } from "./preview-card.js";
+import { PreviewCardDataAttributes } from "./preview-card.slots.js";