@j2-health/design-system 0.1.0

package/dist/src/components/barchart/BarChart.d.ts

@@ -0,0 +1,30 @@
+import { HighchartsReactRefObject } from '@highcharts/react';
+import type * as Highcharts from '../../../node_modules/highcharts/highcharts.src';
+type Series = {
+    name?: string;
+    data: Highcharts.PointOptionsObject[] | number[];
+    color?: string;
+    hoverColor?: string;
+};
+type BarChartProps = {
+    categories: string[];
+    series: Series[];
+    min: number;
+    max: number | undefined | null;
+    tickInterval: number | undefined;
+    tickFormat?: (value: number) => string;
+    xAxisTitle?: string;
+    yAxisTitle?: string;
+    gridLineColor?: string;
+    gridLineDashStyle?: Highcharts.DashStyleValue;
+    xAxisLabelMaxLines?: number;
+    tooltip: (category: string | number | undefined, value: number | null | undefined, seriesName: string | undefined) => React.ReactNode;
+    chartRef?: React.RefObject<HighchartsReactRefObject>;
+    exporting?: Highcharts.ExportingOptions;
+    maxBars?: number;
+    barsWidth?: number;
+    height?: number;
+    width?: number;
+};
+declare const BarChart: ({ categories, series, min, max, tickInterval, tickFormat, xAxisTitle, yAxisTitle, gridLineColor, gridLineDashStyle, xAxisLabelMaxLines, tooltip, exporting, chartRef, height, width, maxBars, barsWidth, }: BarChartProps) => import("react").JSX.Element;
+export { BarChart };

package/dist/src/components/barchart/index.d.ts

@@ -0,0 +1,2 @@
+export { BarChart } from './BarChart';
+export { Chart as HighchartsReact } from '@highcharts/react';

package/dist/src/components/breadcrumb/Breadcrumb.d.ts

@@ -0,0 +1,14 @@
+import { Icon } from '@phosphor-icons/react';
+import { BreadcrumbProps } from 'antd';
+import * as React from 'react';
+type ItemConfig = {
+    title: string;
+    icon?: Icon;
+    href?: string;
+    onClick?: React.MouseEventHandler;
+};
+export type Props = Expand<Omit<BreadcrumbProps, 'items'> & {
+    items: ItemConfig[];
+}>;
+declare const Breadcrumb: ({ items, ...props }: Props) => React.JSX.Element;
+export { Breadcrumb };

package/dist/src/components/breadcrumb/index.d.ts

@@ -0,0 +1 @@
+export { Breadcrumb } from './Breadcrumb';

package/dist/src/components/bulkActionBar/BulkActionBar.d.ts

@@ -0,0 +1,38 @@
+import { ReactNode } from 'react';
+type BulkActionBarProps = {
+    /**
+     * Number of rows currently selected. The bar slides in when count > 0
+     * and slides out when count returns to 0.
+     */
+    count: number;
+    /** Primary action (Archive, Restore, Delete, etc.). */
+    action: {
+        label: string;
+        icon?: ReactNode;
+        loading?: boolean;
+        onClick: () => void;
+    };
+    /** Optional secondary actions rendered between the primary action and Cancel. */
+    secondaryActions?: Array<{
+        label: string;
+        icon?: ReactNode;
+        loading?: boolean;
+        onClick: () => void;
+    }>;
+    /** Clears the selection. Renders as the trailing "Cancel" button. */
+    onCancel: () => void;
+    /** Custom Cancel label. Defaults to `"Cancel"`. */
+    cancelLabel?: string;
+};
+/**
+ * Floating bulk-action toolbar. Renders fixed to the bottom-center of the
+ * viewport and slides in whenever `count > 0`. Use it above any list/table
+ * surface that supports row selection — pair with Ant Design's
+ * `rowSelection` prop on `<Table>` (or any controlled selection state).
+ *
+ * Destructive intent is enforced by whatever confirmation modal the host
+ * surface shows after `action.onClick` — the bar itself is always neutral
+ * (text-on-navy) so it never reads as a one-click destructive control.
+ */
+export declare const BulkActionBar: ({ count, action, secondaryActions, onCancel, cancelLabel, }: BulkActionBarProps) => import("react").JSX.Element;
+export {};

package/dist/src/components/bulkActionBar/index.d.ts

@@ -0,0 +1 @@
+export { BulkActionBar } from './BulkActionBar';

package/dist/src/components/button/Button.d.ts

@@ -0,0 +1,4 @@
+import { ButtonProps } from 'antd';
+export type Props = Expand<ButtonProps>;
+declare const Button: ({ type, size, ghost, danger, shape, ...props }: Props) => import("react").JSX.Element;
+export { Button };

package/dist/src/components/button/index.d.ts

@@ -0,0 +1 @@
+export { Button } from './Button';

package/dist/src/components/card/Card.d.ts

@@ -0,0 +1,19 @@
+import { CardProps } from 'antd';
+export type Props = Omit<CardProps, 'size'> & {
+    /** Card title */
+    title?: string;
+    /** Card contents */
+    children: React.ReactNode;
+    /** Loading state */
+    loading?: boolean;
+    /** Card size */
+    size?: 'default' | 'small' | 'compact' | 'large';
+    /**
+     * Inner card type variant.
+     * It allows inner card to have variants independent of other props.
+     * Works only with type="inner".
+     */
+    innerVariant?: 'default' | 'basic';
+};
+declare const Card: ({ title, children, loading, size, innerVariant, className, ...props }: Props) => import("react").JSX.Element;
+export { Card };

package/dist/src/components/card/index.d.ts

@@ -0,0 +1 @@
+export { Card } from './Card';

package/dist/src/components/checkbox/Checkbox.d.ts

@@ -0,0 +1,7 @@
+import { CheckboxProps } from 'antd';
+type Props = Expand<CheckboxProps>;
+export declare const Checkbox: {
+    (props: Props): import("react").JSX.Element;
+    Group: <T = any>(props: import('antd/es/checkbox').CheckboxGroupProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement;
+};
+export {};

package/dist/src/components/checkbox/index.d.ts

@@ -0,0 +1 @@
+export * from './Checkbox';

package/dist/src/components/checkboxTree/CheckboxTree.d.ts

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+export type CheckboxTreeDataNode = {
+    key: string | number;
+    title: React.ReactNode;
+    children?: CheckboxTreeDataNode[];
+    disabled?: boolean;
+};
+export type CheckboxTreeProps = {
+    treeData: CheckboxTreeDataNode[];
+    defaultCheckedKeys?: (string | number)[];
+    checkedKeys?: (string | number)[];
+    onCheck?: (values: Record<string | number, boolean>, info: {
+        checked: boolean;
+        checkedLeafNodes: Record<string | number, CheckboxTreeDataNode>;
+        allCheckedNodes: CheckboxTreeDataNode[];
+        node: CheckboxTreeDataNode;
+    }) => void;
+    disabled?: boolean;
+    defaultExpandAll?: boolean;
+    defaultExpandedKeys?: (string | number)[];
+    expandedKeys?: (string | number)[];
+    onExpand?: (expandedKeys: (string | number)[]) => void;
+    className?: string;
+    style?: React.CSSProperties;
+    lazyChildren?: boolean;
+};
+export declare const CheckboxTree: ({ treeData, defaultCheckedKeys, checkedKeys: controlledCheckedKeys, onCheck, disabled, defaultExpandAll, defaultExpandedKeys, expandedKeys: controlledExpandedKeys, onExpand, className, style, lazyChildren, }: CheckboxTreeProps) => React.JSX.Element;

package/dist/src/components/checkboxTree/TreeNode.d.ts

@@ -0,0 +1,13 @@
+import { CheckboxTreeDataNode } from './CheckboxTree';
+type TreeNodeProps = {
+    node: CheckboxTreeDataNode;
+    level: number;
+    leafNodeValues: Record<string | number, boolean>;
+    onCheck: (key: string | number, checked: boolean, node: CheckboxTreeDataNode) => void;
+    disabled: boolean;
+    expandedKeys: Set<string | number>;
+    onToggleExpand: (key: string | number) => void;
+    lazyChildren: boolean;
+};
+export declare const TreeNode: ({ node, level, leafNodeValues, onCheck, disabled, expandedKeys, onToggleExpand, lazyChildren, }: TreeNodeProps) => import("react").JSX.Element;
+export {};

package/dist/src/components/checkboxTree/index.d.ts

@@ -0,0 +1 @@
+export * from './CheckboxTree';

package/dist/src/components/checkboxTree/utils.d.ts

@@ -0,0 +1,9 @@
+import { CheckboxTreeDataNode } from './CheckboxTree';
+export declare const getLeafKeys: (node: CheckboxTreeDataNode) => (string | number)[];
+export declare const getAllLeafKeys: (nodes: CheckboxTreeDataNode[]) => (string | number)[];
+export declare const getNodeCheckState: (node: CheckboxTreeDataNode, leafNodeStates: Record<string | number, boolean>) => {
+    checked: boolean;
+    indeterminate: boolean;
+};
+export declare const getAllParentKeys: (nodes: CheckboxTreeDataNode[]) => (string | number)[];
+export declare const findNode: (key: string | number, nodes: CheckboxTreeDataNode[]) => CheckboxTreeDataNode | null;

package/dist/src/components/collapse/Collapse.d.ts

@@ -0,0 +1,9 @@
+import { CollapseProps } from 'antd';
+import * as React from 'react';
+export type CollapseState = 'default' | 'warning' | 'error';
+export type Props = Expand<CollapseProps> & {
+    state?: CollapseState;
+    showIcon?: boolean;
+};
+declare const Collapse: ({ state, showIcon, className, items, ...props }: Props) => React.JSX.Element;
+export { Collapse };

package/dist/src/components/collapse/index.d.ts

@@ -0,0 +1 @@
+export { Collapse } from './Collapse';

package/dist/src/components/drawer/Drawer.d.ts

@@ -0,0 +1,9 @@
+import { DrawerProps } from 'antd';
+type AllProps = Omit<DrawerProps, 'extra' | 'closable'> & {
+    fillPage?: boolean;
+    footer?: React.ReactNode;
+    extraContent?: React.ReactNode;
+};
+export type Props = Expand<AllProps>;
+export declare const Drawer: ({ fillPage, footer, extraContent, ...props }: Props) => import("react").JSX.Element;
+export {};

package/dist/src/components/drawer/index.d.ts

@@ -0,0 +1 @@
+export { Drawer } from './Drawer';

package/dist/src/components/dropdown/Dropdown.d.ts

@@ -0,0 +1,17 @@
+import { DropdownProps } from 'antd';
+export type Props = DropdownProps & {
+    type?: 'basic' | 'basic-inline' | 'twofold';
+    label?: string;
+    icon?: React.ReactNode;
+    menuType?: 'default' | 'slim';
+    targetClassName?: string;
+};
+export type TargetProps = {
+    label?: string;
+    type?: 'basic' | 'basic-inline' | 'twofold';
+    disabled?: boolean;
+    icon?: React.ReactNode;
+    className?: string;
+};
+declare const Dropdown: ({ label, type, icon, menu, menuType, targetClassName, ...props }: Props) => import("react").JSX.Element;
+export { Dropdown };

package/dist/src/components/dropdown/index.d.ts

@@ -0,0 +1 @@
+export { Dropdown } from './Dropdown';

package/dist/src/components/filterform/FilterGroup.d.ts

@@ -0,0 +1,16 @@
+import { FilterConfig } from '.';
+import { FormFilter } from './types';
+type FilterGroupProps = {
+    filterGroup: {
+        field: string;
+        filters: FormFilter[];
+    };
+    groupIndex: number;
+    filterConfigs: FilterConfig[];
+    className?: string;
+    onRemove: (index: number) => void;
+    onChange: (filter: FormFilter, index: number) => void;
+    onDone: (filter: FormFilter, index: number) => void;
+};
+export declare const FilterGroup: ({ filterGroup, groupIndex, filterConfigs, className, onRemove, onChange, onDone, }: FilterGroupProps) => import("react").JSX.Element;
+export {};

package/dist/src/components/filterform/FilterInput.d.ts

@@ -0,0 +1,14 @@
+import { FilterConfig } from '.';
+import { FormFilter } from './types';
+import { SizeType } from 'antd/es/config-provider/SizeContext';
+import * as React from 'react';
+type FilterInputProps = {
+    value?: FormFilter;
+    filterConfigs: FilterConfig[];
+    onChange?: (value: FormFilter) => void;
+    onBlur?: (value: FormFilter) => void;
+    className?: string;
+    size?: SizeType;
+};
+export declare const FilterInput: ({ value, filterConfigs, onChange, onBlur, className, size, }: FilterInputProps) => React.JSX.Element;
+export {};

package/dist/src/components/filterform/FiltersForm.d.ts

@@ -0,0 +1,10 @@
+import { FilterForm, FilterConfig } from '.';
+type Props = {
+    filterConfigs: FilterConfig[];
+    title?: string;
+    onSubmit: (values: FilterForm) => void;
+    initialValues?: FilterForm;
+    maxFiltersPerField?: number;
+};
+export declare const FiltersForm: ({ title, filterConfigs, onSubmit, initialValues, maxFiltersPerField, }: Props) => import("react").JSX.Element;
+export {};

package/dist/src/components/filterform/filterHelpers.d.ts

@@ -0,0 +1,11 @@
+import { Filter, FormFilter } from './types';
+export declare const isEmptyFilter: (filter: Filter) => boolean;
+export declare const isValidFilter: (filter: Filter) => boolean;
+export declare const validateFilterField: (filter: Filter) => {
+    field: string;
+    message: string;
+}[];
+export declare const isEmptyFormFilter: (filter: FormFilter) => boolean;
+export declare const isValidFormFilter: (filter: FormFilter) => boolean;
+export declare const validateFormFilter: (filter: FormFilter) => string[];
+export declare const isFilter: (filter: FormFilter) => filter is Filter;

package/dist/src/components/filterform/index.d.ts

@@ -0,0 +1,2 @@
+export { FiltersForm } from './FiltersForm';
+export type { FilterForm, FilterConfig, FilterType, Filter, FilterGroup, } from './types';

package/dist/src/components/filterform/types.d.ts

@@ -0,0 +1,52 @@
+export type FilterForm = {
+    filters: Filter[];
+};
+export type FormFilter = {
+    field: string;
+    type: FilterType;
+    operator: Operator | undefined;
+    values: (number | string | null | undefined)[];
+    errors?: string[];
+};
+export type FilterGroup = {
+    field: string;
+    filters: FormFilter[];
+};
+export type FilterType = 'select' | 'number' | 'text';
+export type SelectOptionsType = {
+    label: string;
+    value: string;
+}[];
+export type NumberOptionsType = {
+    max: number;
+    min: number;
+    step: number;
+};
+export type FilterConfig = {
+    label: string;
+    field: string;
+    type: FilterType;
+    disabled?: boolean;
+    options?: SelectOptionsType | NumberOptionsType;
+};
+export type Operator = 'equals' | 'notEqual' | 'blank' | 'notBlank' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'inRange' | 'contains' | 'notContains' | 'startsWith' | 'endsWith';
+type SelectFilter = {
+    field: string;
+    type: 'select';
+    operator: Extract<Operator, 'equals' | 'notEqual' | 'blank' | 'notBlank'> | undefined;
+    values: string[];
+};
+type NumberFilter = {
+    field: string;
+    type: 'number';
+    operator: Extract<Operator, 'equals' | 'notEqual' | 'blank' | 'notBlank'> | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'inRange' | undefined;
+    values: number[];
+};
+type TextFilter = {
+    field: string;
+    type: 'text';
+    operator: Extract<Operator, 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'blank' | 'notBlank'> | undefined;
+    values: string[];
+};
+export type Filter = SelectFilter | NumberFilter | TextFilter;
+export {};

package/dist/src/components/filterform/useFilterField.d.ts

@@ -0,0 +1,43 @@
+import { FilterConfig, FilterType, FormFilter, Operator } from './types';
+export type UseFilterFieldInputs = {
+    filterConfigs: FilterConfig[];
+    filter?: FormFilter;
+};
+type UseFilterFieldOutputs = {
+    filter: FormFilter | undefined;
+    config: FilterConfig | undefined;
+    operatorOptions: {
+        label: string;
+        value: string;
+    }[];
+    valueInputConfig: ValueInputConfig | undefined;
+    handleFieldChange: (value: string) => void;
+    handleOperatorChange: (value: string) => void;
+    handleValuesChange: (value: (string | number | undefined | null)[]) => void;
+};
+export declare const TypeToOperatorOptions: Record<FilterType, {
+    label: string;
+    value: Operator;
+}[]>;
+type SelectValueInputConfig = {
+    type: 'select';
+    valueOptions: {
+        label: string;
+        value: string;
+    }[];
+};
+type NumberValueInputConfig = {
+    type: 'number';
+    inputCount: number;
+    numberOptions?: {
+        max: number;
+        min: number;
+        step: number;
+    };
+};
+type TextValueInputConfig = {
+    type: 'text';
+};
+export type ValueInputConfig = SelectValueInputConfig | NumberValueInputConfig | TextValueInputConfig;
+export declare const useFilterField: ({ filterConfigs, filter: initialFilter, }: UseFilterFieldInputs) => UseFilterFieldOutputs;
+export {};

package/dist/src/components/filterform/useFiltersForm.d.ts

@@ -0,0 +1,59 @@
+import { FilterForm, FilterGroup, FormFilter } from './types';
+type UseFiltersFormInput = {
+    initialValues?: FilterForm;
+};
+type UseFiltersFormOutput = {
+    dispatch: (action: Action) => void;
+    filterGroups: FilterGroup[];
+    newFilter: FormFilter | undefined;
+    isNewFilterInputOpen: boolean;
+    isValid: boolean;
+    isEmpty: boolean;
+};
+type InitializeAction = {
+    type: 'initialize';
+    payload: FilterForm | undefined;
+};
+type OpenNewFilterInputAction = {
+    type: 'openNewFilterInput';
+};
+type AddNewFilterAction = {
+    type: 'addNewFilter';
+    payload: FormFilter;
+};
+type ChangeNewFilterAction = {
+    type: 'changeNewFilter';
+    payload: FormFilter;
+};
+type RemoveNewFilterAction = {
+    type: 'removeNewFilter';
+};
+type ClearAllFiltersAction = {
+    type: 'clearAllFilters';
+};
+type UpdateFilterAction = {
+    type: 'updateFilter';
+    payload: {
+        groupIndex: number;
+        filterIndex: number;
+        filter: FormFilter;
+    };
+};
+type ChangeFilterAction = {
+    type: 'changeFilter';
+    payload: {
+        groupIndex: number;
+        filterIndex: number;
+        filter: FormFilter;
+    };
+};
+type RemoveFilterAction = {
+    type: 'removeFilter';
+    payload: {
+        groupIndex: number;
+        filterIndex: number;
+    };
+};
+type Action = AddNewFilterAction | UpdateFilterAction | ClearAllFiltersAction | ChangeNewFilterAction | OpenNewFilterInputAction | ChangeFilterAction | RemoveFilterAction | InitializeAction | RemoveNewFilterAction;
+export declare const useFiltersForm: ({ initialValues, }: UseFiltersFormInput) => UseFiltersFormOutput;
+export {};

package/dist/src/components/form/Form.d.ts

@@ -0,0 +1,7 @@
+import { FormProps } from 'antd';
+type Props = Expand<FormProps>;
+export declare const Form: {
+    ({ children, ...props }: Props): import("react").JSX.Element;
+    Item: ({ name, __debug, showValidateSuccess, showInitialErrorAfterTouched, children, validate, ...restProps }: import('formik-antd').FormItemProps) => JSX.Element;
+};
+export {};

package/dist/src/components/form/index.d.ts

@@ -0,0 +1 @@
+export { Form } from './Form';

package/dist/src/components/icons/index.d.ts

@@ -0,0 +1 @@
+export * from '@phosphor-icons/react';