@ps1ui/core 0.0.0 → 0.1.0

package/dist/components/Stack/Stack.mjs

@@ -0,0 +1,48 @@
+import { cx } from "../../utils/cx.mjs";
+import { resolveResponsive } from "../../utils/responsive.mjs";
+import { spaceToVar } from "../../utils/spacing.mjs";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/Stack/Stack.tsx
+const directionToValue = (v) => v;
+const alignToValue = (v) => {
+	switch (v) {
+		case "start": return "flex-start";
+		case "end": return "flex-end";
+		default: return v;
+	}
+};
+const justifyToValue = (v) => {
+	switch (v) {
+		case "start": return "flex-start";
+		case "end": return "flex-end";
+		case "between": return "space-between";
+		case "around": return "space-around";
+		case "evenly": return "space-evenly";
+		default: return v;
+	}
+};
+const wrapToValue = (v) => v ? "wrap" : "nowrap";
+function Stack({ direction, gap, align, justify, wrap, className, style, ...rest }) {
+	const directionVars = resolveResponsive(direction, "--_stack-direction", directionToValue);
+	const gapVars = resolveResponsive(gap, "--_stack-gap", spaceToVar);
+	const alignVars = resolveResponsive(align, "--_stack-align", alignToValue);
+	const justifyVars = resolveResponsive(justify, "--_stack-justify", justifyToValue);
+	const wrapVars = resolveResponsive(wrap, "--_stack-wrap", wrapToValue);
+	const mergedStyle = {
+		...style,
+		...directionVars,
+		...gapVars,
+		...alignVars,
+		...justifyVars,
+		...wrapVars
+	};
+	return /* @__PURE__ */ jsx("div", {
+		...rest,
+		className: cx("ps1ui-stack", className),
+		style: mergedStyle
+	});
+}
+//#endregion
+export { Stack };
+
+//# sourceMappingURL=Stack.mjs.map

package/dist/components/Stack/Stack.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stack.mjs","names":[],"sources":["../../../src/components/Stack/Stack.tsx"],"sourcesContent":["import type { ComponentProps, CSSProperties } from \"react\";\nimport { cx } from \"../../utils/cx\";\nimport { resolveResponsive, type Responsive } from \"../../utils/responsive\";\nimport { spaceToVar, type SpaceScale } from \"../../utils/spacing\";\n\nexport type StackDirection = \"row\" | \"column\";\nexport type StackGap = SpaceScale;\nexport type StackAlign = \"start\" | \"center\" | \"end\" | \"stretch\" | \"baseline\";\nexport type StackJustify = \"start\" | \"center\" | \"end\" | \"between\" | \"around\" | \"evenly\";\n\nexport type StackProps = ComponentProps<\"div\"> & {\n  /**\n   * Main-axis direction.\n   * @default \"column\"\n   */\n  direction?: Responsive<StackDirection>;\n  /**\n   * Gap between items on the space scale.\n   * @default \"md\"\n   */\n  gap?: Responsive<StackGap>;\n  /** Cross-axis alignment (align-items). */\n  align?: Responsive<StackAlign>;\n  /** Main-axis distribution (justify-content). */\n  justify?: Responsive<StackJustify>;\n  /**\n   * Wrap items onto multiple lines instead of overflowing.\n   * @default false\n   */\n  wrap?: Responsive<boolean>;\n};\n\n// direction values pass straight through — CSS flex-direction accepts\n// `row` / `column` (and `row-reverse` / `column-reverse`, which the union\n// deliberately excludes; add those to the union if the API ever grows).\nconst directionToValue = (v: StackDirection): string => v;\n\n// Flexbox uses `flex-start` / `flex-end` in the box-alignment spec. The\n// StackAlign union exposes the shorter `start` / `end` alias for terseness;\n// the transform remaps them so the CSS variable holds a valid `align-items`\n// value directly.\nconst alignToValue = (v: StackAlign): string => {\n  switch (v) {\n    case \"start\":\n      return \"flex-start\";\n    case \"end\":\n      return \"flex-end\";\n    default:\n      return v;\n  }\n};\n\n// Same treatment as `alignToValue`, plus expansions for the `space-*`\n// justify-content variants.\nconst justifyToValue = (v: StackJustify): string => {\n  switch (v) {\n    case \"start\":\n      return \"flex-start\";\n    case \"end\":\n      return \"flex-end\";\n    case \"between\":\n      return \"space-between\";\n    case \"around\":\n      return \"space-around\";\n    case \"evenly\":\n      return \"space-evenly\";\n    default:\n      return v;\n  }\n};\n\n// boolean → CSS flex-wrap keyword.\nconst wrapToValue = (v: boolean): string => (v ? \"wrap\" : \"nowrap\");\n\nexport function Stack({\n  direction,\n  gap,\n  align,\n  justify,\n  wrap,\n  className,\n  style,\n  ...rest\n}: StackProps) {\n  const directionVars = resolveResponsive(direction, \"--_stack-direction\", directionToValue);\n  const gapVars = resolveResponsive(gap, \"--_stack-gap\", spaceToVar);\n  const alignVars = resolveResponsive(align, \"--_stack-align\", alignToValue);\n  const justifyVars = resolveResponsive(justify, \"--_stack-justify\", justifyToValue);\n  const wrapVars = resolveResponsive(wrap, \"--_stack-wrap\", wrapToValue);\n\n  // Caller style first, internal `--_*` vars win — see Text.tsx. Cast because\n  // csstype has no index signature for `--*` keys (React 19 included).\n  const mergedStyle: CSSProperties = {\n    ...style,\n    ...directionVars,\n    ...gapVars,\n    ...alignVars,\n    ...justifyVars,\n    ...wrapVars,\n  } as CSSProperties;\n\n  return <div {...rest} className={cx(\"ps1ui-stack\", className)} style={mergedStyle} />;\n}\n"],"mappings":";;;;;AAmCA,MAAM,oBAAoB,MAA8B;AAMxD,MAAM,gBAAgB,MAA0B;CAC9C,QAAQ,GAAR;EACE,KAAK,SACH,OAAO;EACT,KAAK,OACH,OAAO;EACT,SACE,OAAO;CACX;AACF;AAIA,MAAM,kBAAkB,MAA4B;CAClD,QAAQ,GAAR;EACE,KAAK,SACH,OAAO;EACT,KAAK,OACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,SACE,OAAO;CACX;AACF;AAGA,MAAM,eAAe,MAAwB,IAAI,SAAS;AAE1D,SAAgB,MAAM,EACpB,WACA,KACA,OACA,SACA,MACA,WACA,OACA,GAAG,QACU;CACb,MAAM,gBAAgB,kBAAkB,WAAW,sBAAsB,gBAAgB;CACzF,MAAM,UAAU,kBAAkB,KAAK,gBAAgB,UAAU;CACjE,MAAM,YAAY,kBAAkB,OAAO,kBAAkB,YAAY;CACzE,MAAM,cAAc,kBAAkB,SAAS,oBAAoB,cAAc;CACjF,MAAM,WAAW,kBAAkB,MAAM,iBAAiB,WAAW;CAIrE,MAAM,cAA6B;EACjC,GAAG;EACH,GAAG;EACH,GAAG;EACH,GAAG;EACH,GAAG;EACH,GAAG;CACL;CAEA,OAAO,oBAAC,OAAD;EAAK,GAAI;EAAM,WAAW,GAAG,eAAe,SAAS;EAAG,OAAO;CAAc,CAAA;AACtF"}

package/dist/components/Table/Table.d.mts

@@ -0,0 +1,7 @@
+import { ComponentProps } from "react";
+//#region src/components/Table/Table.d.ts
+type TableProps = ComponentProps<"table">;
+declare function Table({ className, ref: forwardedRef, ...rest }: TableProps): import("react").JSX.Element;
+//#endregion
+export { Table, TableProps };
+//# sourceMappingURL=Table.d.mts.map

package/dist/components/Table/Table.mjs

@@ -0,0 +1,25 @@
+"use client";
+import { cx } from "../../utils/cx.mjs";
+import { useMergedRef } from "../../utils/useMergedRef.mjs";
+import { useScrollableFocus } from "../../utils/useScrollableFocus.mjs";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/Table/Table.tsx
+function Table({ className, ref: forwardedRef, ...rest }) {
+	const { scrollerRef, contentRef, tabIndex, measure } = useScrollableFocus();
+	const mergedRef = useMergedRef(contentRef, forwardedRef);
+	return /* @__PURE__ */ jsx("div", {
+		className: "ps1ui-table__scroller",
+		tabIndex,
+		ref: scrollerRef,
+		onBlur: measure,
+		children: /* @__PURE__ */ jsx("table", {
+			...rest,
+			ref: mergedRef,
+			className: cx("ps1ui-table", className)
+		})
+	});
+}
+//#endregion
+export { Table };
+
+//# sourceMappingURL=Table.mjs.map

package/dist/components/Table/Table.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Table.mjs","names":[],"sources":["../../../src/components/Table/Table.tsx"],"sourcesContent":["\"use client\";\n\nimport type { ComponentProps } from \"react\";\nimport { cx } from \"../../utils/cx\";\nimport { useMergedRef } from \"../../utils/useMergedRef\";\nimport { useScrollableFocus } from \"../../utils/useScrollableFocus\";\n\n// Props type the native <table>: everything spreads onto the <table> element,\n// ref included. The horizontal-scroll wrapper the component renders around it\n// is an internal implementation detail — it carries no caller props and is\n// styled/targeted via the stable `.ps1ui-table__scroller` class.\nexport type TableProps = ComponentProps<\"table\">;\n\nexport function Table({ className, ref: forwardedRef, ...rest }: TableProps) {\n  // A <table> cannot be its own overflow container (`display: table` boxes\n  // don't honor overflow), so scrolling lives on a wrapper div. Keyboard\n  // reachability of that wrapper — tabIndex only while the table actually\n  // overflows, kept while focused, safe-side under static SSR — is the shared\n  // useScrollableFocus contract (see the hook's header for the full account).\n  // The table's own box is the observed content: children re-rendering wider\n  // or narrower resize it, which re-fires the measurement.\n  const { scrollerRef, contentRef, tabIndex, measure } = useScrollableFocus<\n    HTMLDivElement,\n    HTMLTableElement\n  >();\n\n  // Both the hook (overflow observation) and the caller get the <table> node.\n  const mergedRef = useMergedRef(contentRef, forwardedRef);\n\n  return (\n    <div\n      className=\"ps1ui-table__scroller\"\n      // oxlint-disable-next-line jsx-a11y/no-noninteractive-tabindex -- axe scrollable-region-focusable requires the scroller be keyboard-reachable when the table overflows; useScrollableFocus gates this on measured overflow so small tables stay out of the tab order.\n      tabIndex={tabIndex}\n      ref={scrollerRef}\n      // Re-measure once focus leaves: while focused the hook keeps the tab\n      // stop even if content now fits (dropping tabindex off the focused\n      // element would blur it to <body>); blur is the moment it can safely go.\n      onBlur={measure}\n    >\n      <table {...rest} ref={mergedRef} className={cx(\"ps1ui-table\", className)} />\n    </div>\n  );\n}\n"],"mappings":";;;;;;AAaA,SAAgB,MAAM,EAAE,WAAW,KAAK,cAAc,GAAG,QAAoB;CAQ3E,MAAM,EAAE,aAAa,YAAY,UAAU,YAAY,mBAGrD;CAGF,MAAM,YAAY,aAAa,YAAY,YAAY;CAEvD,OACE,oBAAC,OAAD;EACE,WAAU;EAEA;EACV,KAAK;EAIL,QAAQ;YAER,oBAAC,SAAD;GAAO,GAAI;GAAM,KAAK;GAAW,WAAW,GAAG,eAAe,SAAS;EAAI,CAAA;CACxE,CAAA;AAET"}

package/dist/components/Tbody/Tbody.d.mts

@@ -0,0 +1,7 @@
+import { ComponentProps } from "react";
+//#region src/components/Tbody/Tbody.d.ts
+type TbodyProps = ComponentProps<"tbody">;
+declare function Tbody({ className, ...rest }: TbodyProps): import("react").JSX.Element;
+//#endregion
+export { Tbody, TbodyProps };
+//# sourceMappingURL=Tbody.d.mts.map

package/dist/components/Tbody/Tbody.mjs

@@ -0,0 +1,13 @@
+import { cx } from "../../utils/cx.mjs";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/Tbody/Tbody.tsx
+function Tbody({ className, ...rest }) {
+	return /* @__PURE__ */ jsx("tbody", {
+		...rest,
+		className: cx("ps1ui-tbody", className)
+	});
+}
+//#endregion
+export { Tbody };
+
+//# sourceMappingURL=Tbody.mjs.map

package/dist/components/Tbody/Tbody.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tbody.mjs","names":[],"sources":["../../../src/components/Tbody/Tbody.tsx"],"sourcesContent":["import type { ComponentProps } from \"react\";\nimport { cx } from \"../../utils/cx\";\n\n// Thin typed wrapper for `<tbody>` inside a `<Table>`. Cell styling lives on\n// `.ps1ui-table th / td` in Table.css, so a bare `<tbody>` continues to\n// render identically — Tbody exists to give call sites a stable class hook\n// (`.ps1ui-tbody`) and a documented API surface for what belongs inside a\n// `<Table>` (same contract as ListItem inside List).\nexport type TbodyProps = ComponentProps<\"tbody\">;\n\nexport function Tbody({ className, ...rest }: TbodyProps) {\n  return <tbody {...rest} className={cx(\"ps1ui-tbody\", className)} />;\n}\n"],"mappings":";;;AAUA,SAAgB,MAAM,EAAE,WAAW,GAAG,QAAoB;CACxD,OAAO,oBAAC,SAAD;EAAO,GAAI;EAAM,WAAW,GAAG,eAAe,SAAS;CAAI,CAAA;AACpE"}

package/dist/components/Td/Td.d.mts

@@ -0,0 +1,7 @@
+import { ComponentProps } from "react";
+//#region src/components/Td/Td.d.ts
+type TdProps = ComponentProps<"td">;
+declare function Td({ className, ...rest }: TdProps): import("react").JSX.Element;
+//#endregion
+export { Td, TdProps };
+//# sourceMappingURL=Td.d.mts.map

package/dist/components/Td/Td.mjs

@@ -0,0 +1,13 @@
+import { cx } from "../../utils/cx.mjs";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/Td/Td.tsx
+function Td({ className, ...rest }) {
+	return /* @__PURE__ */ jsx("td", {
+		...rest,
+		className: cx("ps1ui-td", className)
+	});
+}
+//#endregion
+export { Td };
+
+//# sourceMappingURL=Td.mjs.map

package/dist/components/Td/Td.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Td.mjs","names":[],"sources":["../../../src/components/Td/Td.tsx"],"sourcesContent":["import type { ComponentProps } from \"react\";\nimport { cx } from \"../../utils/cx\";\n\n// Thin typed wrapper for `<td>` inside a `<Table>`. Data-cell styling lives\n// on `.ps1ui-table td` in Table.css, so a bare `<td>` continues to render\n// identically — Td exists to give call sites a stable class hook\n// (`.ps1ui-td`) and a documented API surface for what belongs inside a\n// `<Table>` (same contract as ListItem inside List).\nexport type TdProps = ComponentProps<\"td\">;\n\nexport function Td({ className, ...rest }: TdProps) {\n  return <td {...rest} className={cx(\"ps1ui-td\", className)} />;\n}\n"],"mappings":";;;AAUA,SAAgB,GAAG,EAAE,WAAW,GAAG,QAAiB;CAClD,OAAO,oBAAC,MAAD;EAAI,GAAI;EAAM,WAAW,GAAG,YAAY,SAAS;CAAI,CAAA;AAC9D"}

package/dist/components/Text/Text.d.mts

@@ -0,0 +1,31 @@
+import { Responsive } from "../../utils/responsive.mjs";
+import { FontWeight } from "../../utils/typography.mjs";
+import { CSSProperties, ComponentPropsWithoutRef } from "react";
+//#region src/components/Text/Text.d.ts
+type TextElement = "p" | "span" | "div" | "label" | "strong" | "em" | "small";
+type TextVariant = "body" | "muted" | "subtle" | "primary" | "accent";
+type TextSize = "xs" | "sm" | "md" | "lg" | "xl";
+type TextWeight = FontWeight;
+type TextOwnProps<E extends TextElement> = {
+  /** Element to render. */
+  as?: E;
+  /** Color variant. */
+  variant?: TextVariant;
+  /**
+   * Font size on the type scale.
+   * @default "sm"
+   */
+  size?: Responsive<TextSize>;
+  /** Font weight. */
+  weight?: Responsive<TextWeight>;
+  /** Truncate overflowing text with an ellipsis instead of wrapping. */
+  truncate?: boolean;
+};
+type TextProps<E extends TextElement = "p"> = TextOwnProps<E> & Omit<ComponentPropsWithoutRef<E>, keyof TextOwnProps<E>>;
+declare function Text<E extends TextElement = "p">({ as, variant, size, weight, truncate, className, style, ...rest }: TextProps<E>): import("react").ReactElement<Omit<TextProps<E>, "as" | "className" | "size" | "style" | "truncate" | "variant" | "weight"> & {
+  className: string;
+  style: CSSProperties;
+}, string | import("react").JSXElementConstructor<any>>;
+//#endregion
+export { Text, TextElement, TextProps, TextSize, TextVariant, TextWeight };
+//# sourceMappingURL=Text.d.mts.map

package/dist/components/Text/Text.mjs

@@ -0,0 +1,34 @@
+import { cx } from "../../utils/cx.mjs";
+import { resolveResponsive } from "../../utils/responsive.mjs";
+import { fontSizeToVar, weightToValue } from "../../utils/typography.mjs";
+import { createElement } from "react";
+//#region src/components/Text/Text.tsx
+const INLINE_TEXT_ELEMENTS = {
+	p: false,
+	div: false,
+	span: true,
+	label: true,
+	strong: true,
+	em: true,
+	small: true
+};
+function Text({ as, variant = "body", size, weight, truncate = false, className, style, ...rest }) {
+	const tag = as ?? "p";
+	const sizeVars = resolveResponsive(size, "--_text-size", fontSizeToVar);
+	const weightVars = resolveResponsive(weight, "--_text-weight", weightToValue);
+	const classes = cx("ps1ui-text", `ps1ui-text--${variant}`, truncate && "ps1ui-text--truncate", truncate && INLINE_TEXT_ELEMENTS[tag] && "ps1ui-text--truncate-inline", className);
+	const mergedStyle = {
+		...style,
+		...sizeVars,
+		...weightVars
+	};
+	return createElement(tag, {
+		...rest,
+		className: classes,
+		style: mergedStyle
+	});
+}
+//#endregion
+export { Text };
+
+//# sourceMappingURL=Text.mjs.map

package/dist/components/Text/Text.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Text.mjs","names":[],"sources":["../../../src/components/Text/Text.tsx"],"sourcesContent":["import { createElement } from \"react\";\nimport type { ComponentPropsWithoutRef, CSSProperties } from \"react\";\nimport { cx } from \"../../utils/cx\";\nimport { resolveResponsive, type Responsive } from \"../../utils/responsive\";\nimport { fontSizeToVar, weightToValue, type FontWeight } from \"../../utils/typography\";\n\nexport type TextElement = \"p\" | \"span\" | \"div\" | \"label\" | \"strong\" | \"em\" | \"small\";\n\nexport type TextVariant = \"body\" | \"muted\" | \"subtle\" | \"primary\" | \"accent\";\nexport type TextSize = \"xs\" | \"sm\" | \"md\" | \"lg\" | \"xl\";\n// TextWeight is a re-export of the shared FontWeight scale. Keeping a\n// component-local alias preserves the public type name (backwards compat)\n// while the underlying scale stays single-sourced in utils/typography.ts.\nexport type TextWeight = FontWeight;\n\ntype TextOwnProps<E extends TextElement> = {\n  /** Element to render. */\n  as?: E;\n  /** Color variant. */\n  variant?: TextVariant;\n  /**\n   * Font size on the type scale.\n   * @default \"sm\"\n   */\n  size?: Responsive<TextSize>;\n  /** Font weight. */\n  weight?: Responsive<TextWeight>;\n  /** Truncate overflowing text with an ellipsis instead of wrapping. */\n  truncate?: boolean;\n};\n\n// Deliberate exception to the general \"use ComponentProps<'tag'>\" rule other components follow.\n// With the polymorphic `as` prop, TypeScript cannot narrow the `ref` prop's type against the\n// resolved element E — allowing `ref` here would silently accept mismatched ref types\n// (e.g. a ref typed for HTMLParagraphElement on `<Text as=\"span\" ref={…} />`). Keeping `ref`\n// out of the prop type entirely is safer than a misleading loose type; don't switch this\n// to ComponentProps for consistency with the other components.\nexport type TextProps<E extends TextElement = \"p\"> = TextOwnProps<E> &\n  Omit<ComponentPropsWithoutRef<E>, keyof TextOwnProps<E>>;\n\n// Exhaustive over TextElement so adding a tag without classifying it fails to typecheck,\n// instead of silently leaving truncate's inline-block fix un-applied for that tag.\nconst INLINE_TEXT_ELEMENTS: Record<TextElement, boolean> = {\n  p: false,\n  div: false,\n  span: true,\n  label: true,\n  strong: true,\n  em: true,\n  small: true,\n};\n\nexport function Text<E extends TextElement = \"p\">({\n  as,\n  variant = \"body\",\n  size,\n  weight,\n  truncate = false,\n  className,\n  style,\n  ...rest\n}: TextProps<E>) {\n  const tag = as ?? \"p\";\n  const sizeVars = resolveResponsive(size, \"--_text-size\", fontSizeToVar);\n  const weightVars = resolveResponsive(weight, \"--_text-weight\", weightToValue);\n\n  const classes = cx(\n    \"ps1ui-text\",\n    `ps1ui-text--${variant}`,\n    truncate && \"ps1ui-text--truncate\",\n    truncate && INLINE_TEXT_ELEMENTS[tag] && \"ps1ui-text--truncate-inline\",\n    className,\n  );\n\n  // Caller style first, resolved vars last: `--_*` is the reserved internal\n  // prefix and wins on purpose — responsive values are prop-controlled. Cast\n  // because csstype has no index signature for `--*` keys (React 19 included).\n  const mergedStyle: CSSProperties = {\n    ...style,\n    ...sizeVars,\n    ...weightVars,\n  } as CSSProperties;\n\n  return createElement(tag, { ...rest, className: classes, style: mergedStyle });\n}\n"],"mappings":";;;;;AA0CA,MAAM,uBAAqD;CACzD,GAAG;CACH,KAAK;CACL,MAAM;CACN,OAAO;CACP,QAAQ;CACR,IAAI;CACJ,OAAO;AACT;AAEA,SAAgB,KAAkC,EAChD,IACA,UAAU,QACV,MACA,QACA,WAAW,OACX,WACA,OACA,GAAG,QACY;CACf,MAAM,MAAM,MAAM;CAClB,MAAM,WAAW,kBAAkB,MAAM,gBAAgB,aAAa;CACtE,MAAM,aAAa,kBAAkB,QAAQ,kBAAkB,aAAa;CAE5E,MAAM,UAAU,GACd,cACA,eAAe,WACf,YAAY,wBACZ,YAAY,qBAAqB,QAAQ,+BACzC,SACF;CAKA,MAAM,cAA6B;EACjC,GAAG;EACH,GAAG;EACH,GAAG;CACL;CAEA,OAAO,cAAc,KAAK;EAAE,GAAG;EAAM,WAAW;EAAS,OAAO;CAAY,CAAC;AAC/E"}

package/dist/components/Th/Th.d.mts

@@ -0,0 +1,7 @@
+import { ComponentProps } from "react";
+//#region src/components/Th/Th.d.ts
+type ThProps = ComponentProps<"th">;
+declare function Th({ className, ...rest }: ThProps): import("react").JSX.Element;
+//#endregion
+export { Th, ThProps };
+//# sourceMappingURL=Th.d.mts.map

package/dist/components/Th/Th.mjs

@@ -0,0 +1,13 @@
+import { cx } from "../../utils/cx.mjs";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/Th/Th.tsx
+function Th({ className, ...rest }) {
+	return /* @__PURE__ */ jsx("th", {
+		...rest,
+		className: cx("ps1ui-th", className)
+	});
+}
+//#endregion
+export { Th };
+
+//# sourceMappingURL=Th.mjs.map

package/dist/components/Th/Th.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Th.mjs","names":[],"sources":["../../../src/components/Th/Th.tsx"],"sourcesContent":["import type { ComponentProps } from \"react\";\nimport { cx } from \"../../utils/cx\";\n\n// Thin typed wrapper for `<th>` inside a `<Table>`. Header-cell styling\n// lives on `.ps1ui-table th` in Table.css, so a bare `<th>` continues to\n// render identically — Th exists to give call sites a stable class hook\n// (`.ps1ui-th`) and a documented API surface for what belongs inside a\n// `<Table>` (same contract as ListItem inside List). Semantics stay native:\n// pass `scope=\"col\"` / `scope=\"row\"` exactly as you would on a raw <th>.\nexport type ThProps = ComponentProps<\"th\">;\n\nexport function Th({ className, ...rest }: ThProps) {\n  return <th {...rest} className={cx(\"ps1ui-th\", className)} />;\n}\n"],"mappings":";;;AAWA,SAAgB,GAAG,EAAE,WAAW,GAAG,QAAiB;CAClD,OAAO,oBAAC,MAAD;EAAI,GAAI;EAAM,WAAW,GAAG,YAAY,SAAS;CAAI,CAAA;AAC9D"}

package/dist/components/Thead/Thead.d.mts

@@ -0,0 +1,7 @@
+import { ComponentProps } from "react";
+//#region src/components/Thead/Thead.d.ts
+type TheadProps = ComponentProps<"thead">;
+declare function Thead({ className, ...rest }: TheadProps): import("react").JSX.Element;
+//#endregion
+export { Thead, TheadProps };
+//# sourceMappingURL=Thead.d.mts.map

package/dist/components/Thead/Thead.mjs

@@ -0,0 +1,13 @@
+import { cx } from "../../utils/cx.mjs";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/Thead/Thead.tsx
+function Thead({ className, ...rest }) {
+	return /* @__PURE__ */ jsx("thead", {
+		...rest,
+		className: cx("ps1ui-thead", className)
+	});
+}
+//#endregion
+export { Thead };
+
+//# sourceMappingURL=Thead.mjs.map

package/dist/components/Thead/Thead.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Thead.mjs","names":[],"sources":["../../../src/components/Thead/Thead.tsx"],"sourcesContent":["import type { ComponentProps } from \"react\";\nimport { cx } from \"../../utils/cx\";\n\n// Thin typed wrapper for `<thead>` inside a `<Table>`. All header styling\n// lives on `.ps1ui-table thead th` in Table.css, so a bare `<thead>`\n// continues to render identically — Thead exists to give call sites a stable\n// class hook (`.ps1ui-thead`) and a documented API surface for what belongs\n// inside a `<Table>` (same contract as ListItem inside List).\nexport type TheadProps = ComponentProps<\"thead\">;\n\nexport function Thead({ className, ...rest }: TheadProps) {\n  return <thead {...rest} className={cx(\"ps1ui-thead\", className)} />;\n}\n"],"mappings":";;;AAUA,SAAgB,MAAM,EAAE,WAAW,GAAG,QAAoB;CACxD,OAAO,oBAAC,SAAD;EAAO,GAAI;EAAM,WAAW,GAAG,eAAe,SAAS;CAAI,CAAA;AACpE"}

package/dist/components/Tr/Tr.d.mts

@@ -0,0 +1,7 @@
+import { ComponentProps } from "react";
+//#region src/components/Tr/Tr.d.ts
+type TrProps = ComponentProps<"tr">;
+declare function Tr({ className, ...rest }: TrProps): import("react").JSX.Element;
+//#endregion
+export { Tr, TrProps };
+//# sourceMappingURL=Tr.d.mts.map

package/dist/components/Tr/Tr.mjs

@@ -0,0 +1,13 @@
+import { cx } from "../../utils/cx.mjs";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/Tr/Tr.tsx
+function Tr({ className, ...rest }) {
+	return /* @__PURE__ */ jsx("tr", {
+		...rest,
+		className: cx("ps1ui-tr", className)
+	});
+}
+//#endregion
+export { Tr };
+
+//# sourceMappingURL=Tr.mjs.map

package/dist/components/Tr/Tr.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tr.mjs","names":[],"sources":["../../../src/components/Tr/Tr.tsx"],"sourcesContent":["import type { ComponentProps } from \"react\";\nimport { cx } from \"../../utils/cx\";\n\n// Thin typed wrapper for `<tr>` inside a `<Table>`. Cell styling lives on\n// `.ps1ui-table th / td` in Table.css, so a bare `<tr>` continues to render\n// identically — Tr exists to give call sites a stable class hook\n// (`.ps1ui-tr`) and a documented API surface for what belongs inside a\n// `<Table>` (same contract as ListItem inside List).\nexport type TrProps = ComponentProps<\"tr\">;\n\nexport function Tr({ className, ...rest }: TrProps) {\n  return <tr {...rest} className={cx(\"ps1ui-tr\", className)} />;\n}\n"],"mappings":";;;AAUA,SAAgB,GAAG,EAAE,WAAW,GAAG,QAAiB;CAClD,OAAO,oBAAC,MAAD;EAAI,GAAI;EAAM,WAAW,GAAG,YAAY,SAAS;CAAI,CAAA;AAC9D"}