@homebound/beam 2.159.0 → 2.161.0

package/dist/components/AutoSaveIndicator.js

@@ -40,5 +40,5 @@ function AutoSaveIndicator({ hideOnIdle, doNotReset }) {
 }
 exports.AutoSaveIndicator = AutoSaveIndicator;
 function Indicator({ text, icon, color }) {
-    return ((0, jsx_runtime_1.jsxs)("div", Object.assign({ css: Css_1.Css.df.gap1.aic.gray700.smEm.$ }, { children: [(0, jsx_runtime_1.jsx)(Icon_1.Icon, { icon: icon, color: color }, void 0), text] }), void 0));
+    return ((0, jsx_runtime_1.jsxs)("div", Object.assign({ "data-testid": "autoSave", css: Css_1.Css.df.gap1.aic.gray700.smEm.$ }, { children: [(0, jsx_runtime_1.jsx)(Icon_1.Icon, { icon: icon, color: color }, void 0), text] }), void 0));
 }

package/dist/components/Chip.d.ts

@@ -1,5 +1,5 @@
 import { Margin, Only, Xss } from "../Css";
-declare type ChipType = "caution" | "warning" | "success" | "neutral";
+declare type ChipType = "caution" | "warning" | "success" | "light" | "dark" | "neutral";
 export declare const ChipTypes: Record<ChipType, ChipType>;
 export interface ChipProps<X> {
     text: string;

package/dist/components/Chip.js

@@ -10,6 +10,8 @@ exports.ChipTypes = {
     caution: "caution",
     warning: "warning",
     success: "success",
+    light: "light",
+    dark: "dark",
     neutral: "neutral",
 };
 /** Kinda like a chip, but read-only, so no `onClick` or `hover`. */
@@ -29,5 +31,7 @@ const typeStyles = {
     caution: Css_1.Css.bgYellow200.$,
     warning: Css_1.Css.bgRed100.$,
     success: Css_1.Css.bgGreen100.$,
+    light: Css_1.Css.bgWhite.$,
+    dark: Css_1.Css.bgGray900.white.$,
     neutral: Css_1.Css.bgGray200.$,
 };

package/dist/components/Table/GridTable.d.ts

@@ -333,14 +333,26 @@ export declare type GridDataRow<R extends Kinded> = {
     id: string;
     /** A list of parent/grand-parent ids for collapsing parent/child rows. */
     children?: GridDataRow<R>[];
-    /** Whether to pin this sort to the first/last of its parent's children. */
-    pin?: "first" | "last";
+    /** * Whether to pin this sort to the first/last of its parent's children.
+     *
+     * By default, pinned rows are always shown/not filtered out, however providing
+     * the pin `filter: true` property will allow pinned rows to be hidden
+     * while filtering.*/
+    pin?: "first" | "last" | Pin;
     data: unknown;
     /** Whether to have the row collapsed (children not visible) on initial load. This will be ignore in subsequent re-renders of the table */
     initCollapsed?: boolean;
     /** Whether row can be selected */
     selectable?: false;
 } & IfAny<R, {}, DiscriminateUnion<R, "kind", R["kind"]>>;
+/**
+ * Used to indicate where to pin the DataRow and if whether it should be filtered or always visible, setting `filter` to `true` will hide this row
+ * if it doesn't match the provided filtering search term
+ */
+export declare type Pin = {
+    at: "first" | "last";
+    filter?: boolean;
+};
 declare type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
 /** Return the content for a given column def applied to a given row. */
 export declare function applyRowFn<R extends Kinded>(column: GridColumn<R>, row: GridDataRow<R>, api: GridTableApi<R>, level: number): ReactNode | GridCellContent;

package/dist/components/Table/GridTable.js

@@ -822,7 +822,9 @@ function filterRows(api, columns, rows, filter) {
         }
         else {
             const matchedChildren = (_d = (_c = row.children) === null || _c === void 0 ? void 0 : _c.reduce(filterFn, [])) !== null && _d !== void 0 ? _d : [];
-            if (matchedChildren.length > 0 || row.pin) {
+            if (matchedChildren.length > 0 ||
+                typeof row.pin === "string" ||
+                (row.pin !== undefined && row.pin.filter !== true)) {
                 return acc.concat([[row, matchedChildren]]);
             }
             else {

package/dist/components/Table/sortRows.js

@@ -27,8 +27,10 @@ function sortBatch(columns, batch, sortState, caseSensitive) {
             // If both rows are pinned, we don't sort within them, because by pinning the page is taking
             // explicit ownership over the order of the rows (and we also don't support "levels of pins",
             // i.e. for change events putting "just added" rows `pin: last` and the "add new" row `pin: lastest`).
-            const ap = a.pin === "first" ? -1 : a.pin === "last" ? 1 : 0;
-            const bp = b.pin === "first" ? -1 : b.pin === "last" ? 1 : 0;
+            const aPin = getPin(a.pin);
+            const bPin = getPin(b.pin);
+            const ap = aPin === "first" ? -1 : aPin === "last" ? 1 : 0;
+            const bp = bPin === "first" ? -1 : bPin === "last" ? 1 : 0;
             return ap === bp ? 0 : ap < bp ? -1 : 1;
         }
         else if (primaryColumn) {
@@ -42,6 +44,9 @@ function sortBatch(columns, batch, sortState, caseSensitive) {
         return compare(column, a, b, invert, caseSensitive);
     });
 }
+function getPin(pin) {
+    return typeof pin === "string" ? pin : pin === null || pin === void 0 ? void 0 : pin.at;
+}
 function compare(column, a, b, invert, caseSensitive) {
     const v1 = sortValue((0, GridTable_1.applyRowFn)(column, a, {}, 0), caseSensitive);
     const v2 = sortValue((0, GridTable_1.applyRowFn)(column, b, {}, 0), caseSensitive);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homebound/beam",
-  "version": "2.159.0",
+  "version": "2.161.0",
   "author": "Homebound",
   "license": "MIT",
   "main": "dist/index.js",