@linzjs/step-ag-grid 1.5.4 → 2.0.1

package/src/components/gridPopoverEdit/GridPopoverEditBearing.ts

@@ -1,61 +1,69 @@
 import { GenericMultiEditCellClass } from "../GenericCellClass";
-import { GenericCellColDef } from "../gridRender/GridRenderGenericCell";
 import { bearingCorrectionValueFormatter, bearingValueFormatter } from "@utils/bearing";
-import { GridCell } from "../GridCell";
+import { ColDefT, GenericCellEditorProps, GridCell } from "../GridCell";
 import { GridFormEditBearing, GridFormEditBearingProps } from "../gridForm/GridFormEditBearing";
 import { GridBaseRow } from "../Grid";
+import { GenericCellColDef } from "@components/gridRender/GridRenderGenericCell";
 
 export const GridPopoverEditBearingLike = <RowType extends GridBaseRow>(
-  colDef: GenericCellColDef<RowType, GridFormEditBearingProps<RowType>>,
-) =>
-  GridCell<RowType, GridFormEditBearingProps<RowType>>({
-    initialWidth: 65,
-    maxWidth: 150,
-    valueFormatter: bearingValueFormatter,
-    cellClass: colDef.cellEditorParams?.multiEdit ? GenericMultiEditCellClass : undefined,
-    ...colDef,
-    ...(colDef?.cellEditorParams && {
-      cellEditorParams: {
-        ...colDef.cellEditorParams,
-        form: GridFormEditBearing,
-      },
-    }),
-  });
+  colDef: GenericCellColDef<RowType>,
+  props: GenericCellEditorProps<GridFormEditBearingProps<RowType>>,
+): ColDefT<RowType> => {
+  return GridCell(
+    {
+      initialWidth: 65,
+      maxWidth: 150,
+      valueFormatter: bearingValueFormatter,
+      cellClass: props.multiEdit ? GenericMultiEditCellClass : undefined,
+      ...colDef,
+    },
+    {
+      editor: GridFormEditBearing,
+      ...props,
+    },
+  );
+};
 
 export const GridPopoverEditBearing = <RowType extends GridBaseRow>(
-  colDef: GenericCellColDef<RowType, GridFormEditBearingProps<RowType>>,
-) => {
-  const init = GridPopoverEditBearingLike(colDef);
-  return {
-    ...init,
-    valueFormatter: bearingValueFormatter,
-    cellEditorParams: {
-      range: (value: number | null) => {
-        if (value === null) return "Bearing is required";
-        if (value >= 360) return "Bearing must be less than 360 degrees";
-        if (value < 0) return "Bearing must not be negative";
-        return null;
+  colDef: GenericCellColDef<RowType>,
+  props: GenericCellEditorProps<GridFormEditBearingProps<RowType>>,
+): ColDefT<RowType> => {
+  return GridPopoverEditBearingLike(
+    { valueFormatter: bearingValueFormatter, ...colDef },
+    {
+      multiEdit: !!props.multiEdit,
+      editorParams: {
+        placeHolder: "Enter bearing correction",
+        range: (value: number | null) => {
+          if (value === null) return "Bearing correction is required";
+          if (value >= 360) return "Bearing correction must be less than 360 degrees";
+          if (value < 0) return "Bearing correction must not be negative";
+          return null;
+        },
+        ...props.editorParams,
       },
-      ...init.cellEditorParams,
     },
-  };
+  );
 };
 
 export const GridPopoverEditBearingCorrection = <RowType extends GridBaseRow>(
-  colDef: GenericCellColDef<RowType, GridFormEditBearingProps<RowType>>,
-) => {
-  const init = GridPopoverEditBearingLike(colDef);
-  return {
-    ...init,
-    valueFormatter: bearingCorrectionValueFormatter,
-    cellEditorParams: {
-      range: (value: number | null) => {
-        if (value === null) return "Bearing is required";
-        if (value >= 360) return "Bearing must be less than 360 degrees";
-        if (value <= -180) return "Bearing must be greater then -180 degrees";
-        return null;
+  colDef: GenericCellColDef<RowType>,
+  props: GenericCellEditorProps<GridFormEditBearingProps<RowType>>,
+): ColDefT<RowType> => {
+  return GridPopoverEditBearingLike(
+    { valueFormatter: bearingCorrectionValueFormatter, ...colDef },
+    {
+      multiEdit: !!props.multiEdit,
+      editorParams: {
+        placeHolder: "Enter bearing correction",
+        range: (value: number | null) => {
+          if (value === null) return "Bearing is required";
+          if (value >= 360) return "Bearing must be less than 360 degrees";
+          if (value <= -180) return "Bearing must be greater then -180 degrees";
+          return null;
+        },
+        ...props.editorParams,
       },
-      ...init.cellEditorParams,
     },
-  };
+  );
 };

package/src/components/gridPopoverEdit/GridPopoverEditDropDown.ts

@@ -1,21 +1,27 @@
 import { GenericMultiEditCellClass } from "../GenericCellClass";
-import { GenericCellColDef } from "../gridRender/GridRenderGenericCell";
-import { GridCell } from "../GridCell";
+import { ColDefT, GenericCellEditorProps, GridCell } from "../GridCell";
 import { GridBaseRow } from "../Grid";
 import { GridFormDropDown, GridFormPopoutDropDownProps } from "../gridForm/GridFormDropDown";
+import { GenericCellColDef } from "@components/gridRender/GridRenderGenericCell";
 
 export const GridPopoverEditDropDown = <RowType extends GridBaseRow, ValueType>(
-  colDef: GenericCellColDef<RowType, GridFormPopoutDropDownProps<RowType, ValueType>>,
-) =>
-  GridCell<RowType, GridFormPopoutDropDownProps<RowType, ValueType>>({
-    initialWidth: 65,
-    maxWidth: 150,
-    cellClass: colDef.cellEditor?.multiEdit ? GenericMultiEditCellClass : undefined,
-    ...colDef,
-    ...(colDef?.cellEditorParams && {
-      cellEditorParams: {
-        ...colDef.cellEditorParams,
-        form: GridFormDropDown,
+  colDef: GenericCellColDef<RowType>,
+  props: GenericCellEditorProps<GridFormPopoutDropDownProps<RowType, ValueType>>,
+): ColDefT<RowType> =>
+  GridCell(
+    {
+      initialWidth: 65,
+      maxWidth: 150,
+      cellClass: props.multiEdit ? GenericMultiEditCellClass : undefined,
+      ...colDef,
+    },
+    {
+      editor: GridFormDropDown,
+      ...props,
+      editorParams: {
+        // Defaults to medium size container
+        className: "GridPopoverEditDropDown-containerMedium",
+        ...(props.editorParams as GridFormPopoutDropDownProps<RowType, ValueType>),
       },
-    }),
-  });
+    },
+  );

package/src/components/gridPopoverEdit/GridPopoverMenu.scss

@@ -1,13 +1,13 @@
-@use 'node_modules/@linzjs/lui/dist/scss/Core' as lui;
+@use "../../../node_modules/@linzjs/lui/dist/scss/Foundation/Variables/ColorVars" as colors;
 
 .GridPopoutMenu-burger {
   cursor: pointer;
 
-  & svg {
-    fill: lui.$sea;
+  svg {
+    fill: colors.$sea;
   }
 }
 
 .GridPopoutMenu-burgerDisabled svg {
-  fill: lui.$disabled-color;
+  fill: colors.$disabled-color;
 }

package/src/components/gridPopoverEdit/GridPopoverMenu.tsx

@@ -1,35 +1,33 @@
 import "./GridPopoverMenu.scss";
-import "../../react-menu3/styles/index.scss";
 
-import { ColDef } from "ag-grid-community";
 import { GenericMultiEditCellClass } from "../GenericCellClass";
 import { GridBaseRow } from "../Grid";
-import { GridCell } from "../GridCell";
+import { ColDefT, GenericCellEditorProps, GridCell } from "../GridCell";
 import { GridFormPopoutMenu, GridFormPopoutMenuProps } from "../gridForm/GridFormPopoutMenu";
 import { GridRenderPopoutMenuCell } from "../gridRender/GridRenderPopoutMenuCell";
-import { GenericCellColDef } from "../gridRender/GridRenderGenericCell";
+import { GenericCellColDef } from "@components/gridRender/GridRenderGenericCell";
 
 /**
  * Popout burger menu
  */
 export const GridPopoverMenu = <RowType extends GridBaseRow>(
-  colDef: GenericCellColDef<RowType, GridFormPopoutMenuProps<RowType>>,
-): ColDef =>
-  GridCell<RowType, GridFormPopoutMenuProps<RowType>>({
-    maxWidth: 64,
-    editable: colDef.editable != null ? colDef.editable : true,
-    cellRenderer: GridRenderPopoutMenuCell,
-    cellClass: colDef?.cellEditorParams?.multiEdit !== false ? GenericMultiEditCellClass : undefined,
-    ...colDef,
-    cellRendererParams: {
-      // Menus open on single click, this parameter is picked up in Grid.tsx
-      singleClickEdit: true,
-    },
-    ...(colDef?.cellEditorParams && {
-      cellEditorParams: {
-        multiEdit: true,
-        ...colDef.cellEditorParams,
-        form: GridFormPopoutMenu,
+  colDef: GenericCellColDef<RowType>,
+  props: GenericCellEditorProps<GridFormPopoutMenuProps<RowType>>,
+): ColDefT<RowType> =>
+  GridCell<RowType, GridFormPopoutMenuProps<RowType>>(
+    {
+      maxWidth: 64,
+      editable: colDef.editable != null ? colDef.editable : true,
+      cellRenderer: GridRenderPopoutMenuCell,
+      cellClass: colDef?.cellEditorParams?.multiEdit !== false ? GenericMultiEditCellClass : undefined,
+      ...colDef,
+      cellRendererParams: {
+        // Menus open on single click, this parameter is picked up in Grid.tsx
+        singleClickEdit: true,
       },
-    }),
-  });
+    },
+    {
+      editor: GridFormPopoutMenu,
+      ...props,
+    },
+  );

package/src/components/gridPopoverEdit/GridPopoverMessage.ts

@@ -1,22 +1,24 @@
-import { GridCell } from "../GridCell";
+import { ColDefT, GenericCellEditorProps, GridCell } from "../GridCell";
 import { GridFormMessage, GridFormMessageProps } from "../gridForm/GridFormMessage";
 import { GridBaseRow } from "../Grid";
-import { GenericCellColDef } from "../gridRender/GridRenderGenericCell";
+import { GenericCellColDef } from "@components/gridRender/GridRenderGenericCell";
 
 export const GridPopoverMessage = <RowType extends GridBaseRow>(
-  colDef: GenericCellColDef<RowType, GridFormMessageProps<RowType>>,
-) => {
-  return GridCell<RowType, GridFormMessageProps<RowType>>({
-    maxWidth: 140,
-    ...colDef,
-    cellRendererParams: colDef.cellRendererParams ?? {
-      singleClickEdit: true,
-    },
-    ...(colDef?.cellEditorParams && {
-      cellEditorParams: {
-        ...colDef.cellEditorParams,
-        form: GridFormMessage,
+  colDef: GenericCellColDef<RowType>,
+  props: GenericCellEditorProps<GridFormMessageProps<RowType>>,
+): ColDefT<RowType> => {
+  return GridCell(
+    {
+      maxWidth: 140,
+      ...colDef,
+      cellRendererParams: {
+        singleClickEdit: true,
+        ...colDef.cellRendererParams,
       },
-    }),
-  });
+    },
+    {
+      editor: GridFormMessage,
+      ...props,
+    },
+  );
 };

package/src/components/gridPopoverEdit/GridPopoverTextArea.ts

@@ -1,20 +1,16 @@
-import { GridCell } from "../GridCell";
+import { ColDefT, GenericCellEditorProps, GridCell } from "../GridCell";
 import { GridBaseRow } from "../Grid";
-import { GenericCellColDef } from "../gridRender/GridRenderGenericCell";
 import { GridFormTextArea, GridFormTextAreaProps } from "../gridForm/GridFormTextArea";
+import { GenericCellColDef } from "@components/gridRender/GridRenderGenericCell";
 
 export const GridPopoverTextArea = <RowType extends GridBaseRow>(
-  colDef: GenericCellColDef<RowType, GridFormTextAreaProps<RowType>>,
-) => {
-  return GridCell<RowType, GridFormTextAreaProps<RowType>>({
-    maxWidth: 260,
-    ...colDef,
-    ...(colDef?.cellEditorParams && {
-      cellEditorParams: {
-        width: 260,
-        ...colDef.cellEditorParams,
-        form: GridFormTextArea,
-      },
-    }),
-  });
-};
+  colDef: GenericCellColDef<RowType>,
+  params: GenericCellEditorProps<GridFormTextAreaProps<RowType>>,
+): ColDefT<RowType> =>
+  GridCell(
+    {
+      maxWidth: 260,
+      ...colDef,
+    },
+    { editor: GridFormTextArea, ...params },
+  );

package/src/components/gridPopoverEdit/GridPopoverTextInput.ts

@@ -1,20 +1,20 @@
-import { GridCell } from "../GridCell";
+import { ColDefT, GenericCellEditorProps, GridCell } from "../GridCell";
 import { GridBaseRow } from "../Grid";
-import { GenericCellColDef } from "../gridRender/GridRenderGenericCell";
 import { GridFormTextInput, GridFormTextInputProps } from "../gridForm/GridFormTextInput";
+import { GenericCellColDef } from "@components/gridRender/GridRenderGenericCell";
 
 export const GridPopoverTextInput = <RowType extends GridBaseRow>(
-  colDef: GenericCellColDef<RowType, GridFormTextInputProps<RowType>>,
-) => {
-  return GridCell<RowType, GridFormTextInputProps<RowType>>({
-    maxWidth: 140,
-    ...colDef,
-    ...(colDef?.cellEditorParams && {
-      cellEditorParams: {
-        width: 240,
-        ...colDef.cellEditorParams,
-        form: GridFormTextInput,
-      },
-    }),
-  });
+  colDef: GenericCellColDef<RowType>,
+  params: GenericCellEditorProps<GridFormTextInputProps<RowType>>,
+): ColDefT<RowType> => {
+  return GridCell(
+    {
+      maxWidth: 140,
+      ...colDef,
+    },
+    {
+      editor: GridFormTextInput,
+      ...params,
+    },
+  );
 };

package/src/components/gridRender/GridRenderGenericCell.tsx

@@ -1,21 +1,20 @@
-import "./GridRenderGenericCell.scss";
+import "../../styles/GridRenderGenericCell.scss";
 
 import { useContext } from "react";
-import { UpdatingContext } from "@contexts/UpdatingContext";
+import { GridUpdatingContext } from "@contexts/GridUpdatingContext";
 import { GridLoadableCell } from "../GridLoadableCell";
 import { GridIcon } from "../GridIcon";
 import { ColDef, ICellRendererParams } from "ag-grid-community";
 import { ValueFormatterParams } from "ag-grid-community/dist/lib/entities/colDef";
-import { GenericCellEditorParams } from "../GridCell";
 import { GridBaseRow } from "../Grid";
+import { ColDefT } from "@components/GridCell";
 
 export interface RowICellRendererParams<RowType extends GridBaseRow> extends ICellRendererParams {
   data: RowType;
 }
 
-export interface GenericCellColDef<RowType extends GridBaseRow, FormProps extends Record<string, any>> extends ColDef {
+export interface GenericCellColDef<RowType extends GridBaseRow> extends ColDefT<RowType> {
   cellRendererParams?: GenericCellRendererParams<RowType>;
-  cellEditorParams?: GenericCellEditorParams<RowType> & FormProps;
 }
 
 export interface GenericCellRendererParams<RowType extends GridBaseRow> {
@@ -25,7 +24,7 @@ export interface GenericCellRendererParams<RowType extends GridBaseRow> {
 }
 
 export const GridRendererGenericCell = <RowType extends GridBaseRow>(props: ICellRendererParams): JSX.Element => {
-  const { checkUpdating } = useContext(UpdatingContext);
+  const { checkUpdating } = useContext(GridUpdatingContext);
 
   const colDef = props.colDef as ColDef;
   const cellRendererParams = colDef.cellRendererParams as GenericCellRendererParams<RowType> | undefined;

package/src/components/gridRender/GridRenderPopoutMenuCell.tsx

@@ -1,12 +1,12 @@
 import { useContext } from "react";
 import { ColDef, ICellRendererParams } from "ag-grid-community";
-import { UpdatingContext } from "@contexts/UpdatingContext";
+import { GridUpdatingContext } from "@contexts/GridUpdatingContext";
 import { GridLoadableCell } from "../GridLoadableCell";
 import { LuiIcon } from "@linzjs/lui";
 import { Column } from "ag-grid-community/dist/lib/entities/column";
 
 export const GridRenderPopoutMenuCell = (props: ICellRendererParams) => {
-  const { checkUpdating } = useContext(UpdatingContext);
+  const { checkUpdating } = useContext(GridUpdatingContext);
   const isLoading = checkUpdating(props.colDef?.field ?? "", props.data.id);
   const editable = props.colDef?.editable;
   const disabled = !(typeof editable === "function"

package/src/contexts/GridContext.tsx

@@ -7,7 +7,7 @@ export interface GridContextType {
   setGridApi: (gridApi: GridApi | undefined) => void;
   setQuickFilter: (quickFilter: string) => void;
   editingCells: () => boolean;
-  getSelectedRows: <T extends unknown>() => T[];
+  getSelectedRows: <T extends GridBaseRow>() => T[];
   getSelectedRowIds: () => number[];
   selectRowsDiff: (updateFn: () => Promise<any>) => Promise<void>;
   selectRowsWithFlashDiff: (updateFn: () => Promise<any>) => Promise<void>;

package/src/contexts/GridContextProvider.tsx

@@ -3,7 +3,7 @@ import { GridApi, RowNode } from "ag-grid-community";
 import { GridContext } from "./GridContext";
 import { delay, difference, isEmpty, last, sortBy } from "lodash-es";
 import { isNotEmpty } from "@utils/util";
-import { UpdatingContext } from "./UpdatingContext";
+import { GridUpdatingContext } from "./GridUpdatingContext";
 import { GridBaseRow } from "@components/Grid";
 
 interface GridContextProps {
@@ -16,7 +16,7 @@ interface GridContextProps {
  * Also, make sure the provider is created in a separate component, otherwise it won't be found.
  */
 export const GridContextProvider = (props: GridContextProps): ReactElement => {
-  const { modifyUpdating } = useContext(UpdatingContext);
+  const { modifyUpdating } = useContext(GridUpdatingContext);
   const gridApiRef = useRef<GridApi>();
   const idsBeforeUpdate = useRef<number[]>([]);
 
@@ -48,9 +48,7 @@ export const GridContextProvider = (props: GridContextProps): ReactElement => {
       noApiFn = (() => {}) as () => R;
     }
     const gridApi = gridApiRef.current;
-    if (gridApi) return hasApiFn(gridApi);
-    console.error("GridApi not ready");
-    return noApiFn();
+    return gridApi ? hasApiFn(gridApi) : noApiFn();
   };
 
   /**

package/src/contexts/GridPopoverContext.tsx

@@ -0,0 +1,26 @@
+import { createContext, RefObject } from "react";
+import { ICellEditorParams } from "ag-grid-community";
+
+export interface PropsType {
+  value: any;
+  data: any;
+  field: string;
+  selectedRows: any[];
+  updateValue: (saveFn: (selectedRows: any[]) => Promise<boolean>) => Promise<boolean>;
+}
+
+export type GridPopoverContextType = {
+  anchorRef: RefObject<Element>;
+  saving: boolean;
+  setSaving: (saving: boolean) => void;
+  setProps: (props: ICellEditorParams, multiEdit: boolean) => void;
+  propsRef: RefObject<PropsType>;
+};
+
+export const GridPopoverContext = createContext<GridPopoverContextType>({
+  anchorRef: { current: null },
+  saving: false,
+  setSaving: () => {},
+  setProps: () => {},
+  propsRef: { current: null },
+});

package/src/contexts/GridPopoverContextProvider.tsx

@@ -0,0 +1,54 @@
+import { ReactNode, RefObject, useCallback, useContext, useRef, useState } from "react";
+import { GridPopoverContext, PropsType } from "./GridPopoverContext";
+import { ICellEditorParams } from "ag-grid-community";
+import { GridContext } from "@contexts/GridContext";
+import { sortBy } from "lodash-es";
+import { GridBaseRow } from "@components/Grid";
+
+interface GridPopoverContextProps {
+  children: ReactNode;
+}
+
+export const GridPopoverContextProvider = (props: GridPopoverContextProps) => {
+  const { getSelectedRows, updatingCells } = useContext(GridContext);
+  const anchorRef = useRef<Element>();
+  const propsRef = useRef<PropsType>({} as PropsType);
+
+  const [saving, setSaving] = useState(false);
+
+  const setProps = useCallback(
+    (props: ICellEditorParams, multiEdit: boolean) => {
+      // Then item that is clicked on will always be first in the list
+      const selectedRows = multiEdit
+        ? sortBy(getSelectedRows(), (row) => row.id !== props.data.id)
+        : [props.data as GridBaseRow];
+      const field = props.colDef?.field ?? "";
+
+      anchorRef.current = props.eGridCell;
+      propsRef.current = {
+        value: props.value,
+        data: props.data,
+        field,
+        selectedRows,
+        updateValue: async (saveFn: (selectedRows: any[]) => Promise<boolean>): Promise<boolean> => {
+          return !saving && (await updatingCells({ selectedRows, field }, saveFn, setSaving));
+        },
+      };
+    },
+    [getSelectedRows, saving, updatingCells],
+  );
+
+  return (
+    <GridPopoverContext.Provider
+      value={{
+        anchorRef: anchorRef as any as RefObject<Element>,
+        saving,
+        setSaving,
+        propsRef,
+        setProps,
+      }}
+    >
+      {props.children}
+    </GridPopoverContext.Provider>
+  );
+};

package/src/contexts/{UpdatingContext.tsx → GridUpdatingContext.tsx}

@@ -1,11 +1,11 @@
 import { createContext } from "react";
 
-export type UpdatingContextType = {
+export type GridUpdatingContextType = {
   checkUpdating: (fields: string | string[], id: number | string) => boolean;
   modifyUpdating: (field: string, ids: (number | string)[], fn: () => void | Promise<void>) => Promise<void>;
 };
 
-export const UpdatingContext = createContext<UpdatingContextType>({
+export const GridUpdatingContext = createContext<GridUpdatingContextType>({
   checkUpdating: () => {
     console.error("Missing UpdatingContext");
     return false;

package/src/contexts/{UpdatingContextProvider.tsx → GridUpdatingContextProvider.tsx}

@@ -1,23 +1,23 @@
 import { ReactNode, useRef } from "react";
 import { castArray, flatten, remove } from "lodash-es";
-import { UpdatingContext } from "./UpdatingContext";
+import { GridUpdatingContext } from "./GridUpdatingContext";
 
 interface UpdatingContextProviderProps {
   children: ReactNode;
 }
 
-export type UpdatingContextStatus = Record<string, (number | string)[] | undefined>;
+export type GridUpdatingContextStatus = Record<string, (number | string)[] | undefined>;
 
 type FieldName = string;
 type IdList = (number | string)[];
 type UpdatingBlock = Record<FieldName, IdList[]>;
 
-export const UpdatingContextProvider = (props: UpdatingContextProviderProps) => {
+export const GridUpdatingContextProvider = (props: UpdatingContextProviderProps) => {
   const updatingBlocks = useRef<UpdatingBlock>({});
-  const updating = useRef<UpdatingContextStatus>({});
+  const updating = useRef<GridUpdatingContextStatus>({});
 
   const resetUpdating = () => {
-    const mergedUpdatingBlocks: UpdatingContextStatus = {};
+    const mergedUpdatingBlocks: GridUpdatingContextStatus = {};
     for (const key in updatingBlocks.current) {
       mergedUpdatingBlocks[key] = flatten(updatingBlocks.current[key]);
     }
@@ -38,6 +38,8 @@ export const UpdatingContextProvider = (props: UpdatingContextProviderProps) =>
     castArray(fields).some((f) => updating.current[f]?.includes(id));
 
   return (
-    <UpdatingContext.Provider value={{ modifyUpdating, checkUpdating }}>{props.children}</UpdatingContext.Provider>
+    <GridUpdatingContext.Provider value={{ modifyUpdating, checkUpdating }}>
+      {props.children}
+    </GridUpdatingContext.Provider>
   );
 };

package/src/index.ts

@@ -0,0 +1,38 @@
+export * from "@react-menu3";
+export * from "./react-menu3/types";
+
+export * from "@contexts/GridUpdatingContext";
+export * from "@contexts/GridUpdatingContextProvider";
+export * from "@contexts/GridContext";
+export * from "@contexts/GridContextProvider";
+
+export type { GridBaseRow } from "@components/Grid";
+export { Grid } from "@components/Grid";
+export * from "@components/GridCell";
+export { GridIcon } from "@components/GridIcon";
+export { ComponentLoadingWrapper } from "@components/ComponentLoadingWrapper";
+export { GenericMultiEditCellClass } from "@components/GenericCellClass";
+export { GridLoadableCell } from "@components/GridLoadableCell";
+export { useGridPopoverHook } from "@components/GridPopoverHook";
+export { usePostSortRowsHook } from "@components/PostSortRowsHook";
+
+export { GridRendererGenericCell } from "@components/gridRender/GridRenderGenericCell";
+export { GridRenderPopoutMenuCell } from "@components/gridRender/GridRenderPopoutMenuCell";
+
+export { GridPopoutEditMultiSelect } from "@components/gridPopoverEdit/GridPopoutEditMultiSelect";
+export { GridPopoverMenu } from "@components/gridPopoverEdit/GridPopoverMenu";
+export { GridPopoverEditBearing } from "@components/gridPopoverEdit/GridPopoverEditBearing";
+export { GridPopoverEditBearingCorrection } from "@components/gridPopoverEdit/GridPopoverEditBearing";
+export { GridPopoverEditDropDown } from "@components/gridPopoverEdit/GridPopoverEditDropDown";
+export { GridPopoverMessage } from "@components/gridPopoverEdit/GridPopoverMessage";
+export { GridPopoverTextArea } from "@components/gridPopoverEdit/GridPopoverTextArea";
+export { GridPopoverTextInput } from "@components/gridPopoverEdit/GridPopoverTextInput";
+
+export { GridHeaderSelect } from "@components/gridHeader/GridHeaderSelect";
+
+export { TextAreaInput } from "./lui/TextAreaInput";
+export { TextInputFormatted } from "./lui/TextInputFormatted";
+export { GridSubComponentTextArea } from "@components/GridSubComponentTextArea";
+
+export * from "@utils/bearing";
+export * from "@utils/util";

package/src/lui/TextInputFormatted.scss

@@ -8,4 +8,4 @@
   top: 0;
   line-height: 48px;
   color: #beb9b4;
-}
+}