@bysages/svelte 0.2.2 → 0.2.3

package/dist/index-BFL_M4PT.d.mts

@@ -0,0 +1,25 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/progress-group/props.d.ts
+/** One verdict on the bar. */
+interface ProgressSegment {
+  value: number;
+  label?: string;
+  pigment?: "primary" | "success" | "warning" | "danger" | "info";
+}
+interface ProgressGroupProps extends HTMLAttributes<HTMLDivElement> {
+  segments: ProgressSegment[];
+  max?: number;
+  showLegend?: boolean;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/progress-group/index.d.ts
+/** One bar, several verdicts: the segments stand shoulder to shoulder,
+ * each as wide as its share of the whole and speaking its own pigment;
+ * the legend reads them back beneath (swatch, label, value) unless the
+ * caller declines it. The whole is the sum of the parts unless the
+ * caller brings a larger one — the remainder then shows as groove. */
+declare const ProgressGroup: import("svelte").Component<ProgressGroupProps, {}, "">;
+//#endregion
+export { ProgressGroupProps as n, ProgressSegment as r, ProgressGroup as t };

package/dist/index-BHlsL8ta.d.mts

@@ -0,0 +1,30 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/card/props.d.ts
+interface CardProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+interface CardTitleProps extends HTMLAttributes<HTMLHeadingElement> {
+  children?: Snippet;
+}
+interface CardDescriptionProps extends HTMLAttributes<HTMLParagraphElement> {
+  children?: Snippet;
+}
+interface CardPartProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/card/index.d.ts
+/** A vessel: round, resting at the first elevation, one hairline for its
+ * edge. Root, Header, Title, Description, Content, Footer — sections
+ * carry their own whitespace, so any subset composes. */
+declare const Card: import("svelte").Component<CardProps, {}, ""> & {
+  Root: import("svelte").Component<CardProps, {}, "">;
+  Header: import("svelte").Component<CardPartProps, {}, "">;
+  Title: import("svelte").Component<CardTitleProps, {}, "">;
+  Description: import("svelte").Component<CardDescriptionProps, {}, "">;
+  Content: import("svelte").Component<CardPartProps, {}, "">;
+  Footer: import("svelte").Component<CardPartProps, {}, "">;
+};
+//#endregion
+export { CardTitleProps as a, CardProps as i, CardDescriptionProps as n, CardPartProps as r, Card as t };

package/dist/index-BIIMyeLK.d.mts

@@ -0,0 +1,12 @@
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/spinner/props.d.ts
+interface SpinnerProps extends HTMLAttributes<HTMLElement> {
+  size?: "sm" | "md" | "lg";
+}
+//#endregion
+//#region src/components/spinner/index.d.ts
+/** A wheel of waiting: one arc of ink turning about its center. Quiet by
+ * default — it reports progress without claiming attention. */
+declare const Spinner: import("svelte").Component<SpinnerProps, {}, "">;
+//#endregion
+export { SpinnerProps as n, Spinner as t };

package/dist/index-BTndXl0q.d.mts

@@ -0,0 +1,15 @@
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/chip/props.d.ts
+interface ChipProps extends HTMLAttributes<HTMLSpanElement> {
+  value: number;
+  max?: number;
+  tone?: "ink" | "info" | "success" | "warning" | "danger";
+  variant?: "solid" | "subtle" | "outline";
+}
+//#endregion
+//#region src/components/chip/index.d.ts
+/** A counting coin: the numeric value, capped at `max` with an ellipsis
+ * of the remainder ("99+"). */
+declare const Chip: import("svelte").Component<ChipProps, {}, "">;
+//#endregion
+export { ChipProps as n, Chip as t };

package/dist/index-BahdqXg4.d.mts

@@ -0,0 +1,58 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/layout/props.d.ts
+interface LayoutProps extends HTMLAttributes<HTMLDivElement> {
+  /** Declare which edge the skeleton reserves for its sider — without
+   * it the root is a single column. */
+  sider?: "start" | "end";
+  children?: Snippet;
+}
+/** A semantic block of the skeleton — header, footer, and the flow's
+ * main content each land on their native element and their grid area. */
+interface LayoutRegionProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+interface LayoutSiderProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+  /** The caller drives the fold — `bind:collapsed` mirrors every
+   * change. */
+  collapsed?: boolean;
+  /** The rail's resting inline size — a layout parameter, not a visual
+   * token, so it rides an inline variable. Bindable: the drag and the
+   * arrow keys write through it. */
+  width?: string;
+  /** The inline size when folded. */
+  collapsedWidth?: string;
+  /** Offer the hairline at the flow edge: the rail's width follows the
+   * hand (and the arrow keys), clamped by min/max, and every change
+   * rides `bind:width`. */
+  resizable?: boolean;
+  /** The rail's narrowest inline size while resizing. */
+  minWidth?: string;
+  /** The rail's widest inline size while resizing. */
+  maxWidth?: string;
+  /** Receives the fold state, so a rail can swap its labels for icons
+   * instead of being clipped mid-word by the narrowing edge. */
+  children?: Snippet<[{
+    collapsed: boolean;
+  }]>;
+}
+//#endregion
+//#region src/components/layout/context.d.ts
+/** Which edge the enclosing root reserves for its rail — shared so the
+ * sider's resize handle knows which way the hand pulls. */
+interface LayoutContext {
+  siderPlacement: () => "start" | "end" | undefined;
+}
+//#endregion
+//#region src/components/layout/index.d.ts
+/** The application skeleton: Root, Header, Sider, Content, Footer —
+ * the admin arrangement dressed in the paper-and-ink surfaces. */
+declare const Layout: import("svelte").Component<LayoutProps, {}, ""> & {
+  Root: import("svelte").Component<LayoutProps, {}, "">;
+  Header: import("svelte").Component<LayoutRegionProps, {}, "">;
+  Sider: import("svelte").Component<LayoutSiderProps, {}, "width" | "collapsed">;
+  Content: import("svelte").Component<LayoutRegionProps, {}, "">;
+  Footer: import("svelte").Component<LayoutRegionProps, {}, "">;
+};
+//#endregion
+export { LayoutSiderProps as a, LayoutRegionProps as i, LayoutContext as n, LayoutProps as r, Layout as t };

package/dist/index-BgLAlGbg.d.mts

@@ -0,0 +1,28 @@
+import { Snippet } from "svelte";
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/timeline/props.d.ts
+interface TimelineProps extends HTMLAttributes<HTMLOListElement> {
+  children?: Snippet;
+}
+interface TimelineItemProps extends HTMLAttributes<HTMLLIElement> {
+  children?: Snippet;
+}
+interface TimelineMarkerProps extends HTMLAttributes<HTMLSpanElement> {
+  children?: Snippet;
+}
+interface TimelineContentProps extends HTMLAttributes<HTMLDivElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/timeline/index.d.ts
+/** A line of moments: Root is the ordered thread, Item one moment on it,
+ * Marker the point where the thread passes, Content what the moment
+ * holds. The hairline between markers is drawn by the stylesheet. */
+declare const Timeline: import("svelte").Component<TimelineProps, {}, ""> & {
+  Root: import("svelte").Component<TimelineProps, {}, "">;
+  Item: import("svelte").Component<TimelineItemProps, {}, "">;
+  Marker: import("svelte").Component<TimelineMarkerProps, {}, "">;
+  Content: import("svelte").Component<TimelineContentProps, {}, "">;
+};
+//#endregion
+export { TimelineProps as a, TimelineMarkerProps as i, TimelineContentProps as n, TimelineItemProps as r, Timeline as t };

package/dist/index-Bj2IsU9D.d.mts

@@ -0,0 +1,26 @@
+import { HTMLAttributes } from "svelte/elements";
+//#region src/components/tree-select/props.d.ts
+interface TreeSelectNode {
+  label: string;
+  value: string;
+  children?: TreeSelectNode[];
+  disabled?: boolean;
+}
+interface TreeSelectProps extends HTMLAttributes<HTMLButtonElement> {
+  /** Two-way bindable — `bind:value` keeps the bound variable mirroring
+   * the chosen leaf. */
+  value?: string;
+  data: TreeSelectNode[];
+  placeholder?: string;
+  /** Put a filter line at the top of the vessel; matches keep their
+   * ancestors and the branches fan open. */
+  filterable?: boolean;
+  disabled?: boolean;
+}
+//#endregion
+//#region src/components/tree-select/index.d.ts
+/** A tree behind a field: the control reads like an input, the vessel
+ * below walks the hierarchy, and one leaf click closes the deal. */
+declare const TreeSelect: import("svelte").Component<TreeSelectProps, {}, "value">;
+//#endregion
+export { TreeSelectNode as n, TreeSelectProps as r, TreeSelect as t };