@bysages/svelte 0.2.1 → 0.2.3

package/dist/index-D8F1dVDW.d.mts

@@ -0,0 +1,59 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/float-button/props.d.ts
+type FloatButtonPlacement = "bottom-end" | "bottom-start" | "top-end" | "top-start";
+type FloatButtonSize = "sm" | "md" | "lg";
+interface FloatButtonProps extends HTMLAttributes<HTMLDivElement> {
+  /** Controlled openness — `bind:open` receives every flip; leave it
+   * unbound and the group holds its own state. */
+  open?: boolean;
+  /** Which corner the group moors at. */
+  placement?: FloatButtonPlacement;
+  /** One rung of the button ladder for the whole group. */
+  size?: FloatButtonSize;
+  children?: Snippet;
+}
+interface FloatButtonTriggerProps {
+  /** The accessible name; the control is icon-only. */
+  label?: string;
+  children?: Snippet;
+}
+interface FloatButtonItemProps {
+  /** The action's name: the button's accessible name and the
+   * annotation surfaced beside it while the group is open. */
+  label: string;
+  disabled?: boolean;
+  /** Fired when the item's action is chosen — the fan folds right
+   * after. */
+  onclick?: () => void;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/float-button/context.d.ts
+/** The group's openness, shared from the mooring to its parts. */
+interface FloatButtonContext {
+  /** Live openness — read through the getter, so parts re-render as it
+   * flips. */
+  readonly open: boolean;
+  /** The group's button rung; the trigger takes it whole, the items
+   * step down one. */
+  readonly size: FloatButtonSize;
+  toggle: () => void;
+  /** Folds the fan — an Item calls this once its action fires, the way
+   * a speed dial closes after a choice. */
+  close: () => void;
+}
+/** Context key for {@link FloatButtonContext}, exported so a custom
+ * part can read the group's state. */
+declare const FLOAT_BUTTON_KEY: unique symbol;
+//#endregion
+//#region src/components/float-button/index.d.ts
+/** A floating action and its fanned-out alternatives — FAB and speed
+ * dial in one family. Root, Trigger, Item. */
+declare const FloatButton: import("svelte").Component<FloatButtonProps, {}, "open"> & {
+  Root: import("svelte").Component<FloatButtonProps, {}, "open">;
+  Trigger: import("svelte").Component<FloatButtonTriggerProps, {}, "">;
+  Item: import("svelte").Component<FloatButtonItemProps, {}, "">;
+};
+//#endregion
+export { FloatButtonPlacement as a, FloatButtonItemProps as i, FLOAT_BUTTON_KEY as n, FloatButtonProps as o, FloatButtonContext as r, FloatButtonTriggerProps as s, FloatButton as t };

package/dist/index-DAesWvpj.d.mts

@@ -0,0 +1,22 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/image/props.d.ts
+interface ImageProps extends HTMLAttributes<HTMLElement> {
+  src: string;
+  alt?: string;
+  fit?: "cover" | "contain" | "fill" | "none";
+  loading?: "lazy" | "eager";
+  /** What a broken source leaves — the quiet placeholder glyph by
+   * default. */
+  fallback?: Snippet;
+}
+//#endregion
+//#region src/components/image/index.d.ts
+/** A framed picture: while the source loads, the frame keeps the
+ * skeleton's breath; the picture dissolves in when it lands; a broken
+ * source leaves the fallback snippet — or the placeholder glyph when
+ * the caller has nothing local to say. The frame's size is the
+ * consumer's to give. */
+declare const Image: import("svelte").Component<ImageProps, {}, "">;
+//#endregion
+export { ImageProps as n, Image as t };

package/dist/index-DH0ecZNW.d.mts

@@ -0,0 +1,25 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/alert/props.d.ts
+type AlertStatus = "ink" | "info" | "success" | "warning" | "danger";
+interface AlertProps extends HTMLAttributes<HTMLDivElement> {
+  status?: AlertStatus;
+  children?: Snippet;
+}
+interface AlertPartProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/alert/index.d.ts
+/** A notice drawn on the page: a wash of the status pigment, one heavier
+ * hairline on the leading edge, the serif for its title. Root, Icon,
+ * Body, Title, Description — the icon reads the status from the Root. */
+declare const Alert: import("svelte").Component<AlertProps, {}, ""> & {
+  Root: import("svelte").Component<AlertProps, {}, "">;
+  Icon: import("svelte").Component<AlertPartProps, {}, "">;
+  Body: import("svelte").Component<AlertPartProps, {}, "">;
+  Title: import("svelte").Component<AlertPartProps, {}, "">;
+  Description: import("svelte").Component<AlertPartProps, {}, "">;
+};
+//#endregion
+export { AlertStatus as i, AlertPartProps as n, AlertProps as r, Alert as t };

package/dist/index-DKDpZraB.d.mts

@@ -0,0 +1,67 @@
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/mentions/props.d.ts
+interface MentionEntry {
+  label: string;
+  value: string;
+}
+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;
+}
+interface MentionsProps extends HTMLAttributes<HTMLDivElement> {
+  /** The candidates offered once the trigger character is typed. */
+  items?: MentionEntry[];
+  /** Two-way bindable — `bind:value` keeps the bound variable mirroring
+   * 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 announces itself invalid; 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 turned. */
+  onValueChange?: (value: string) => void;
+}
+interface MentionsVesselProps {
+  open?: boolean;
+  matches?: MentionEntry[];
+  active?: number;
+  /** The live rectangle the vessel points at — the host's field. */
+  anchor?: HTMLTextAreaElement | null;
+  /** The host field's rung, so the rows keep the field's register. */
+  size?: "sm" | "md" | "lg";
+  /** A candidate was confirmed (click or Enter). */
+  onInsert?: (entry: MentionEntry) => void;
+  /** The keyboard's active row moved. */
+  onActiveChange?: (index: number) => void;
+  /** The vessel's open state turned. */
+  onOpenChange?: (open: boolean) => void;
+}
+//#endregion
+//#region src/components/mentions/index.d.ts
+/** @-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 `bind:value`. Arrows move, Enter inserts, Escape dismisses. */
+declare const Mentions: import("svelte").Component<MentionsProps, {}, "value">;
+/** The vessel: the candidates themselves as a floating card. Composers
+ * that keep their own field anatomy wire it up with `useMentions`
+ * directly. */
+declare const MentionsVessel: import("svelte").Component<MentionsVesselProps, {}, "">;
+//#endregion
+export { MentionsVesselProps as a, MentionsProps as i, MentionsVessel as n, UseMentionsHandlers as o, MentionEntry as r, UseMentionsOptions as s, Mentions as t };

package/dist/index-DKfQGayE.d.mts

@@ -0,0 +1,19 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/input-group/props.d.ts
+interface InputGroupProps extends HTMLAttributes<HTMLDivElement> {
+  children?: Snippet;
+}
+interface InputGroupAddonProps extends HTMLAttributes<HTMLDivElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/input-group/index.d.ts
+/** Merged controls: attachments and the entry fused into one seal —
+ * Root, Addon. */
+declare const InputGroup: import("svelte").Component<InputGroupProps, {}, ""> & {
+  Root: import("svelte").Component<InputGroupProps, {}, "">;
+  Addon: import("svelte").Component<InputGroupAddonProps, {}, "">;
+};
+//#endregion
+export { InputGroupAddonProps as n, InputGroupProps as r, InputGroup as t };

package/dist/index-DOcn6bMd.d.mts

@@ -0,0 +1,15 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/ellipsis/props.d.ts
+interface EllipsisProps extends HTMLAttributes<HTMLSpanElement> {
+  lines?: number;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/ellipsis/index.d.ts
+/** The overflow knife: text cut at one line, or held to N lines. The
+ * primitive only draws the cut — reaching the full text (title,
+ * tooltip) stays the consumer's decision. */
+declare const Ellipsis: import("svelte").Component<EllipsisProps, {}, "">;
+//#endregion
+export { EllipsisProps as n, Ellipsis as t };

package/dist/index-DTAcdUAd.d.mts

@@ -0,0 +1,48 @@
+import { ThemeScene } from "@bysages/core";
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/config-provider/context.d.ts
+/** The four density tiers the token layer's `[data-density]` selectors
+ * name — whitespace and control heights compress, readability never
+ * does. */
+type ConfigDensity = "compact" | "default" | "comfortable" | "spacious";
+/** The named scene registers the token layer's `[data-scene]` selectors
+ * retune — "auto" is the engine's own resolution and stays off the
+ * subtree vocabulary. */
+type ConfigScene = Exclude<ThemeScene, "auto">;
+/** The configuration a provider lays over its subtree. Every field is
+ * optional: an absent field changes nothing, and the page's own
+ * attributes keep ruling. */
+interface ConfigContext {
+  density?: ConfigDensity;
+  scene?: ConfigScene;
+  /** A mineral pigment theme (qinghua, celadon, zhusha, …) landing as
+   * `[data-accent]` on the host element. */
+  accent?: string;
+  /** Writing direction, landing as the native `dir` attribute. */
+  dir?: "ltr" | "rtl";
+  /** BCP-47 locale, landing as the native `lang` attribute. */
+  locale?: string;
+}
+/** The nearest provider's live snapshot, or an empty one when no
+ * provider wraps the caller. */
+declare function useConfig(): ConfigContext;
+//#endregion
+//#region src/components/config-provider/props.d.ts
+interface ConfigProviderProps extends HTMLAttributes<HTMLDivElement> {
+  density?: ConfigDensity;
+  scene?: ConfigScene;
+  accent?: string;
+  dir?: "ltr" | "rtl";
+  /** BCP-47 locale, landing as the native `lang` attribute. */
+  locale?: string;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/config-provider/index.d.ts
+/** The declarative host for global configuration: one element carrying
+ * the token layer's attributes and providing the same values to
+ * descendants through `useConfig`. */
+declare const ConfigProvider: import("svelte").Component<ConfigProviderProps, {}, "">;
+//#endregion
+export { useConfig as a, ConfigDensity as i, ConfigProviderProps as n, ConfigContext as r, ConfigProvider as t };

package/dist/index-D_cE3qK2.d.mts

@@ -0,0 +1,44 @@
+//#region src/components/command/props.d.ts
+interface CommandEntry {
+  label: string;
+  value: string;
+  /** Entries sharing a group are listed under one heading. */
+  group?: string;
+  /** A short affordance note, set as a keycap at the row's end. */
+  hint?: string;
+}
+interface CommandProps {
+  /** The commands on offer, grouped as they arrive. */
+  items?: CommandEntry[];
+  placeholder?: string;
+  /** Whether the palette is up. Bind it (`bind:open`) to control the
+   * palette; changes are reported through `onOpenChange`. */
+  open?: boolean;
+  /** Whether the shell narrows `items` as the reader types. Turn it off
+   * when the caller owns the searching — a ranked engine or a remote
+   * source — and hands down the already-narrowed list. */
+  autoFilter?: boolean;
+  /** The field's text under the caller's control; changes are reported
+   * through `onInputValueChange`. */
+  inputValue?: string;
+  /** What the list whispers when nothing matches. */
+  emptyText?: string;
+  /** Called with the chosen entry's `value`; the palette closes after. */
+  onSelect?: (value: string) => void;
+  /** The palette's open state turned. */
+  onOpenChange?: (open: boolean) => void;
+  /** The field's live text turned. */
+  onInputValueChange?: (inputValue: string) => void;
+}
+//#endregion
+//#region src/components/command/index.d.ts
+/** The command palette: a modal sheet at the top of the page carrying a
+ * search field over the caller's commands, grouped as a ledger with a
+ * keycap hint at each row. The shell is the dialog machinery — scrim,
+ * focus trap, Escape — and the searching is the combobox machinery
+ * driving our own list: the vessel and the list live inside the sheet,
+ * so the combobox renders no separate popup and the machine's content
+ * grafts onto the sheet's list. */
+declare const Command: import("svelte").Component<CommandProps, {}, "open">;
+//#endregion
+export { CommandEntry as n, CommandProps as r, Command as t };

package/dist/index-DfTAYXUT.d.mts

@@ -0,0 +1,16 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/avatar-group/props.d.ts
+interface AvatarGroupProps extends HTMLAttributes<HTMLDivElement> {
+  /** One register for every seal: falls onto data-size for the
+   * stylesheet to re-point the avatars' measure. */
+  size?: "sm" | "md" | "lg";
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/avatar-group/index.d.ts
+/** Avatars overlapping one row, each rimmed in the ground so the pile
+ * stays legible. */
+declare const AvatarGroup: import("svelte").Component<AvatarGroupProps, {}, "">;
+//#endregion
+export { AvatarGroupProps as n, AvatarGroup as t };

package/dist/index-DlHvtlYT.d.mts

@@ -0,0 +1,28 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/meter/props.d.ts
+interface MeterRootProps extends HTMLAttributes<HTMLDivElement> {
+  /** The measured value — clamped between min and max. */
+  value: number;
+  min?: number;
+  max?: number;
+  /** The pigment the ink rides: primary unless a threshold is crossed. */
+  level?: "normal" | "success" | "warning" | "danger";
+  label?: string;
+  children?: Snippet;
+}
+interface MeterPartProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/meter/index.d.ts
+/** A measure in the world, not a task in flight: how much of the toner
+ * remains, how full the cistern stands. The level chooses the pigment. */
+declare const Meter: import("svelte").Component<MeterRootProps, {}, ""> & {
+  Root: import("svelte").Component<MeterRootProps, {}, "">;
+  Label: import("svelte").Component<MeterPartProps, {}, "">;
+  ValueText: import("svelte").Component<MeterPartProps, {}, "">;
+  Track: import("svelte").Component<MeterPartProps, {}, "">;
+};
+//#endregion
+export { MeterPartProps as n, MeterRootProps as r, Meter as t };

package/dist/index-Dr-T8jsb.d.mts

@@ -0,0 +1,82 @@
+import { CellData, ColumnDef, ColumnDef as ColumnDef$1, FlexRender as FlexRender$1, RowData, SortingState, SortingState as SortingState$1, TableFeatures, createColumnHelper } from "@tanstack/svelte-table";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/table/props.d.ts
+/** One-stop data table on TanStack Table v9, dressed in the paper-and-ink
+ * system: rows are CSS grids under ARIA table semantics, so sticky headers,
+ * pinned columns, merged cells, and a virtualized window all stay honest
+ * while sorting, filtering, tree expansion, selection, and pagination come
+ * from the row-model pipeline. */
+interface DataTableProps extends HTMLAttributes<HTMLDivElement> {
+  /** Row data; replaced wholesale on change — TanStack's memoized row
+   * models keep unrelated rows untouched, so edits land without a full
+   * re-render. Tree rows nest under `subRows`. */
+  data: RowData[];
+  /** Column definitions (TanStack `ColumnDef`, preferably built with
+   * `createColumnHelper().columns([...])`). Give every column an `id`
+   * unless it uses `accessorKey`. `size` fixes a px width; `minSize`
+   * floors a flexing track; otherwise the track hugs its content and
+   * only the table's leftover width is shared between columns. */
+  columns: ColumnDef<any, any, any>[];
+  /** Render a leading checkbox column with select-all. */
+  selectable?: boolean;
+  /** Allow header-click sorting (default true). */
+  sortable?: boolean;
+  /** Render a global-filter toolbar and per-column filter inputs. */
+  filterable?: boolean;
+  /** Keep the built-in toolbar row above the table (default true when
+   * `filterable`). Turn it off to host the global filter in your own
+   * toolbar — the feature stays registered and the instance methods
+   * keep working. */
+  showToolbar?: boolean;
+  /** Enable tree expansion over `subRows`; the first column hosts the
+   * expander and depth indent. */
+  tree?: boolean;
+  /** Column ids whose equal adjacent values merge into one cell (mutually
+   * exclusive with `virtual`). */
+  merge?: string[];
+  /** Column ids pinned to the start edge. */
+  pinStart?: string[];
+  /** Column ids pinned to the end edge. */
+  pinEnd?: string[];
+  /** Virtualize the body through a fixed-height window (mutually exclusive
+   * with `merge`). */
+  virtual?: boolean;
+  /** Row height in px; must match CSS so the virtual window aligns. */
+  rowHeight?: number;
+  /** Render the pagination bar and slice rows client-side. */
+  paginated?: boolean;
+  pageSize?: number;
+  pageSizeOptions?: number[];
+  /** Keep the (optional) footer row pinned to the viewport bottom. */
+  stickyFooter?: boolean;
+  initialSorting?: SortingState;
+  globalFilterPlaceholder?: string;
+  emptyText?: string;
+  /** Allow dragging header cells onto each other to reorder columns and
+   * body rows onto each other to reorder data — with `tree`, row drops
+   * read as before / inside / after, so a drop can also nest a branch
+   * under its target. Rows need a stable `id`. Row dragging rests while
+   * sorting or filtering hides the data order. */
+  reorderable?: boolean;
+  /** Fires with the reordered data array (the whole tree in tree mode). */
+  onRowReorder?: (rows: RowData[]) => void;
+  /** Fires with the full leaf-column id order after a header drop. */
+  onColumnReorder?: (ids: string[]) => void;
+}
+//#endregion
+//#region src/components/table/index.d.ts
+/** The control recipe as a one-stop data table: sorting, filtering,
+ * pinning, merging, virtualization, and drag-to-reorder behind one
+ * component. The API is TanStack's own — columns ride `ColumnDef`. */
+declare const DataTable: import("svelte").Component<DataTableProps, {}, "">;
+/** Column metadata understood by this table: mark columns whose values
+ * read right-aligned in tabular figures. The type parameters mirror the
+ * library's own declaration — augmentation merging demands an identical
+ * parameter list. */
+declare module "@tanstack/svelte-table" {
+  interface ColumnMeta<in out TFeatures extends TableFeatures, in out TData extends RowData, TValue extends CellData = CellData> {
+    numeric?: boolean;
+  }
+}
+//#endregion
+export { createColumnHelper as a, SortingState$1 as i, DataTable as n, DataTableProps as o, FlexRender$1 as r, ColumnDef$1 as t };

package/dist/index-DrXCIscJ.d.mts

@@ -0,0 +1,19 @@
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/input/props.d.ts
+interface InputProps extends HTMLAttributes<HTMLInputElement> {
+  /** Two-way bindable — `bind:value` keeps the bound variable mirroring
+   * the field. */
+  value?: string | number;
+  size?: "sm" | "md" | "lg";
+  /** Standing alone this styles the control invalid; inside a Field
+   * the context's invalid state joins in. */
+  invalid?: boolean;
+}
+//#endregion
+//#region src/components/input/index.d.ts
+/** The bare text input, dressed in the field recipe: border, surface,
+ * focus halo — no shadow. Inside a Field.Root it picks up the label
+ * wiring and the invalid state from the context. */
+declare const Input: import("svelte").Component<InputProps, {}, "value">;
+//#endregion
+export { InputProps as n, Input as t };

package/dist/index-Dy335EhR.d.mts

@@ -0,0 +1,15 @@
+import { t as ClipboardRoot } from "./ClipboardRoot-UmyQFn27.mjs";
+import { Clipboard, ClipboardRootProps } from "@ark-ui/svelte/clipboard";
+//#region src/components/clipboard/props.d.ts
+type ClipboardRootProps$1 = ClipboardRootProps & {
+  /** One rung of the control-height ladder for the value field and
+   * its copy seal. */
+  size?: "sm" | "md" | "lg";
+};
+//#endregion
+//#region src/components/clipboard/index.d.ts
+declare const Clipboard$1: Omit<typeof Clipboard, "Root"> & {
+  Root: typeof ClipboardRoot;
+};
+//#endregion
+export { ClipboardRootProps$1 as n, Clipboard$1 as t };

package/dist/index-KxuOZGfm.d.mts

@@ -0,0 +1,14 @@
+import { t as ListboxRoot } from "./ListboxRoot-DhFAnZ_c.mjs";
+import { CollectionItem, Listbox, ListboxRootProps } from "@ark-ui/svelte/listbox";
+//#region src/components/listbox/props.d.ts
+type ListboxRootProps$1 = ListboxRootProps<CollectionItem> & {
+  /** One rung of the ladder for the row register and the filter field. */
+  size?: "sm" | "md" | "lg";
+};
+//#endregion
+//#region src/components/listbox/index.d.ts
+declare const Listbox$1: Omit<typeof Listbox, "Root"> & {
+  Root: typeof ListboxRoot;
+};
+//#endregion
+export { ListboxRootProps$1 as n, Listbox$1 as t };

package/dist/index-NJ21Q4f4.d.mts

@@ -0,0 +1,25 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/descriptions/props.d.ts
+interface DescriptionsRootProps extends HTMLAttributes<HTMLDListElement> {
+  /** The horizontal layout reads as a table of two columns; the
+   * vertical one stacks each pair for narrow measures. */
+  layout?: "horizontal" | "vertical";
+  children?: Snippet;
+}
+interface DescriptionsPartProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/descriptions/index.d.ts
+/** A ledger laid flat: term and detail pairs in one quiet grid. The
+ * horizontal layout reads as a table of two columns; the vertical one
+ * stacks each pair for narrow measures. */
+declare const Descriptions: import("svelte").Component<DescriptionsRootProps, {}, ""> & {
+  Root: import("svelte").Component<DescriptionsRootProps, {}, "">;
+  Item: import("svelte").Component<DescriptionsPartProps, {}, "">;
+  Term: import("svelte").Component<DescriptionsPartProps, {}, "">;
+  Detail: import("svelte").Component<DescriptionsPartProps, {}, "">;
+};
+//#endregion
+export { DescriptionsPartProps as n, DescriptionsRootProps as r, Descriptions as t };