@bysages/solid 0.2.1 → 0.2.3

package/dist/index-DDX7x8aT.d.mts

@@ -0,0 +1,95 @@
+import { Accessor, JSX } from "solid-js";
+//#region src/components/mentions/use-mentions.d.ts
+interface UseMentionsOptions {
+  /** The candidates offered once the trigger character is typed. */
+  items: MentionEntry[];
+  /** The character that summons the candidates. */
+  trigger?: string;
+}
+interface UseMentionsHandlers {
+  /** The text the field holds right now — read at keystroke time, never
+   * from a controlled prop that lags a render behind the caret. */
+  getText: () => string;
+  /** Writes the field's next text: a mention inserted at the token. */
+  setText: (value: string) => void;
+}
+/** The @-detection machinery behind a mention field: watch the caret,
+ * offer the matching candidates, and answer for the keys that drive
+ * them. The field element arrives as an accessor because hosts wrap it
+ * differently (a bare textarea, a field's own part).
+ *
+ * `onKeydown` answers whether the vessel consumed the key, so a host
+ * with its own Enter semantics — a composer that sends — can yield to
+ * the candidates first and act only when the vessel stands down. */
+declare function useMentions(options: Accessor<UseMentionsOptions>, textarea: Accessor<HTMLTextAreaElement | null>, handlers: UseMentionsHandlers): {
+  open: Accessor<boolean>;
+  matches: Accessor<MentionEntry[]>;
+  active: Accessor<number>;
+  setActive: import("solid-js").Setter<number>;
+  insert: (entry: MentionEntry) => void;
+  close: () => void;
+  onInput: () => void;
+  onKeydown: (event: KeyboardEvent) => boolean;
+};
+//#endregion
+//#region src/components/mentions/index.d.ts
+interface MentionEntry {
+  label: string;
+  value: string;
+}
+interface MentionsVesselProps {
+  open?: boolean;
+  matches?: MentionEntry[];
+  active?: number;
+  /** The live element the vessel points at — the anchor is virtual, a
+   * rectangle read off the host's field. */
+  anchor?: HTMLTextAreaElement | null;
+  /** The host field's rung, so the rows keep the field's register. */
+  size?: "sm" | "md" | "lg";
+  onInsert?: (entry: MentionEntry) => void;
+  onActiveChange?: (index: number) => void;
+  onOpenChange?: (open: boolean) => void;
+}
+/** The vessel: the candidates themselves as a floating card. The anchor
+ * is virtual — a live rectangle off the host's field — so a host keeps
+ * its own anatomy (the textarea rides where the host puts it) and the
+ * vessel still points at the right place. Shares the detection state
+ * with the host through `useMentions`. */
+declare function MentionsVessel(props: MentionsVesselProps): JSX.Element;
+interface MentionsProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, "onInput"> {
+  /** The candidates offered once the trigger character is typed. */
+  items?: MentionEntry[];
+  /** The text held by the field. Supply it to control the field;
+   * changes are reported through `onValueChange`. */
+  value?: string;
+  /** The character that summons the candidates. */
+  trigger?: string;
+  placeholder?: string;
+  /** Let the field grow with its text instead of holding `rows`. */
+  autoresize?: boolean;
+  /** Standing alone, the field styles itself from this flag; inside a
+   * `Field.Root` the field's own invalid state takes over. */
+  invalid?: boolean;
+  /** One rung of the control-height ladder for the resting field. */
+  size?: "sm" | "md" | "lg";
+  /** The field's text changed. */
+  onValueChange?: (value: string) => void;
+}
+/**
+ * @-mentions: a plain textarea that, when the text before the caret ends
+ * with the trigger character followed by a token, offers the matching
+ * candidates in a small anchored vessel; choosing one replaces the token
+ * with `trigger + label` and hands the whole text back through
+ * `onValueChange`. Arrows move, Enter inserts, Escape dismisses.
+ *
+ * The field is the shared `Textarea` — field wiring (label ids, the
+ * invalid state) rides on it for free — and the vessel anchors to the
+ * field as a whole (popover machinery), not to the caret coordinates;
+ * caret-precise positioning would need a second positioning system for
+ * no practical gain at typical field sizes. Composers that keep their
+ * own field anatomy (the AI prompt input) skip this shell and wire
+ * `useMentions` plus `MentionsVessel` themselves.
+ */
+declare function Mentions(props: MentionsProps): JSX.Element;
+//#endregion
+export { MentionsVesselProps as a, useMentions as c, MentionsVessel as i, Mentions as n, UseMentionsHandlers as o, MentionsProps as r, UseMentionsOptions as s, MentionEntry as t };