@infomaximum/ui-kit 0.15.8 → 0.16.0

package/dist/components/Table/hooks/useTableColumns/useTableColumns.js

@@ -0,0 +1,39 @@
+import { useMemo } from "react";
+import { flatColumns } from "./useTableColumns.utils.js";
+import { useTransformColumns } from "../../features/tableRowSelection/hooks/useTransformColumns/useTransformColumns.js";
+import { useTransformColumns as useTransformColumns$1 } from "../../features/tableSort/hooks/useTransformColumns/useTransformColumns.js";
+const emptyColumnKey = "__EMPTY_COLUMN";
+const useTableColumns = (options) => {
+  const {
+    columns: columnsProp,
+    rowSelection
+  } = options;
+  const {
+    transformColumns: rowSelectionTransformColumns
+  } = useTransformColumns({
+    rowSelection
+  });
+  const {
+    transformColumns: sorterTransformColumns
+  } = useTransformColumns$1();
+  const columns = useMemo(() => {
+    const transformers = [sorterTransformColumns, rowSelectionTransformColumns];
+    const resultColumns = transformers.reduce((transformedColumns, transformer) => transformer(transformedColumns), [...columnsProp]);
+    if (!resultColumns.length) {
+      resultColumns.push({
+        key: emptyColumnKey
+      });
+    }
+    return resultColumns;
+  }, [columnsProp, rowSelectionTransformColumns, sorterTransformColumns]);
+  const flattedColumns = useMemo(() => flatColumns(columns), [columns]);
+  const isAllColumnsFixedStart = useMemo(() => flattedColumns.every((col) => col.fixed === "start"), [flattedColumns]);
+  return {
+    columns,
+    flattedColumns,
+    isAllColumnsFixedStart
+  };
+};
+export {
+  useTableColumns
+};

package/dist/components/Table/hooks/useTableColumns/useTableColumns.types.d.ts

@@ -0,0 +1,4 @@
+import { UseTransformColumnsOptions } from 'components/Table/features/tableRowSelection';
+import { DefaultRecord, TableProps } from '../../Table.types';
+export interface UseTableColumnsOptions<Record extends DefaultRecord> extends Pick<TableProps<Record>, "columns">, UseTransformColumnsOptions<Record> {
+}

package/dist/components/Table/hooks/useTableColumns/useTableColumns.utils.d.ts

@@ -0,0 +1,2 @@
+import { Column, Columns } from 'components/Table/interfaces/tableColumns.types';
+export declare const flatColumns: <Record>(columns: Columns<Record>) => Column<Record>[];

package/dist/components/Table/hooks/useTableColumns/useTableColumns.utils.js

@@ -0,0 +1,24 @@
+const flatColumns = (columns) => {
+  return columns.reduce((acc, column) => {
+    const {
+      fixed
+    } = column;
+    const subColumns = "children" in column ? column.children : [];
+    if (subColumns.length > 0) {
+      return [...acc, ...flatColumns(subColumns).map((subColumn) => {
+        const clonedSubColumn = {
+          ...subColumn
+        };
+        const resultFixed = subColumn.fixed ?? fixed;
+        if (resultFixed) {
+          clonedSubColumn.fixed = resultFixed;
+        }
+        return clonedSubColumn;
+      })];
+    }
+    return [...acc, column];
+  }, []);
+};
+export {
+  flatColumns
+};

package/dist/components/Table/hooks/useTableComponents/index.d.ts

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

package/dist/components/Table/hooks/useTableComponents/useTableComponents.d.ts

@@ -0,0 +1,6 @@
+import { PropertyPath } from 'lodash-es';
+import { UseTableComponentsOptions } from './useTableComponents.types';
+import { CustomizedComponent } from 'components/Table/interfaces/tableComponents.types';
+export declare const useTableComponents: (options: UseTableComponentsOptions) => {
+    getComponent: <T extends CustomizedComponent>(path: PropertyPath, defaultComponent: T) => T;
+};

package/dist/components/Table/hooks/useTableComponents/useTableComponents.js

@@ -0,0 +1,14 @@
+import { useCallback } from "react";
+import { get } from "lodash-es";
+const useTableComponents = (options) => {
+  const {
+    components
+  } = options;
+  const getComponent = useCallback((path, defaultComponent) => get(components, path, defaultComponent), [components]);
+  return {
+    getComponent
+  };
+};
+export {
+  useTableComponents
+};

package/dist/components/Table/hooks/useTableComponents/useTableComponents.types.d.ts

@@ -0,0 +1,3 @@
+import { TableProps } from '../../Table.types';
+export interface UseTableComponentsOptions extends Pick<TableProps, "components"> {
+}

package/dist/components/Table/hooks/useTableVisualParamsChange/index.d.ts

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

package/dist/components/Table/hooks/useTableVisualParamsChange/types.d.ts

@@ -0,0 +1,4 @@
+import { DefaultRecord, TableProps } from 'components/Table/Table.types';
+export interface UseTableVisualParamsChangeOptions<Record extends DefaultRecord> extends Pick<TableProps<Record>, "onScroll"> {
+    fixColumn?: boolean;
+}

package/dist/components/Table/hooks/useTableVisualParamsChange/useTableVisualParamsChange.d.ts

@@ -0,0 +1,12 @@
+import { UIEventHandler } from 'react';
+import { UseTableVisualParamsChangeOptions } from './types';
+import { OnResize } from 'rc-resize-observer';
+import { DefaultRecord } from 'components/Table/Table.types';
+export declare const useTableVisualParamsChange: <Record extends DefaultRecord>(options: UseTableVisualParamsChangeOptions<Record>) => {
+    onTableContentScroll: UIEventHandler<HTMLDivElement>;
+    onResize: OnResize;
+    onTableHeaderScroll: UIEventHandler<HTMLDivElement>;
+    onTableBodyScroll: UIEventHandler<HTMLDivElement>;
+    scrollableTableSectionRef: import('react').RefObject<HTMLDivElement>;
+    tableHeaderRef: import('react').RefObject<HTMLDivElement>;
+};

package/dist/components/Table/hooks/useTableVisualParamsChange/useTableVisualParamsChange.js

@@ -0,0 +1,116 @@
+import { useRef, useLayoutEffect, useCallback } from "react";
+import { useEvent } from "../../../../hooks/useEvent/useEvent.js";
+import "rc-resize-observer";
+import { getVerticalScrollBarWidth, forceScroll, getHorizontalScrollPositionRange } from "./utils.js";
+import { useTableStaticContext } from "../../features/tableStaticContext/contexts/tableStaticContext/useTableStaticContext/useTableStaticContext.js";
+import { useEmitter } from "../../features/typedEventBus/hooks.js";
+import { updateRefValue, getRefValue } from "../../utils/ref/ref.js";
+const useTableVisualParamsChange = (options) => {
+  const {
+    fixColumn,
+    onScroll
+  } = options;
+  const staticContextRef = useTableStaticContext();
+  const tableHeaderRef = useRef(null);
+  const scrollableTableSectionRef = useRef(null);
+  const emitTableVisualParamsChange = useEvent(useEmitter("table-visual-params:change"));
+  useLayoutEffect(() => {
+    const scrollableTableSection = scrollableTableSectionRef.current;
+    if (!scrollableTableSection) {
+      return;
+    }
+    const horizontalScrollPositionRange = getHorizontalScrollPositionRange(scrollableTableSection);
+    const verticalScrollBarWidth = getVerticalScrollBarWidth(scrollableTableSection);
+    const {
+      clientWidth
+    } = scrollableTableSection;
+    updateRefValue(staticContextRef, {
+      scrollableTableSectionInfo: {
+        horizontalScrollPositionRange,
+        clientWidth,
+        verticalScrollBarWidth
+      }
+    });
+    const measureCellsInfo = getRefValue(staticContextRef, "measureCellsInfo");
+    emitTableVisualParamsChange({
+      horizontalScrollPositionRange,
+      verticalScrollBarWidth,
+      clientWidth,
+      measureCellsInfo
+    });
+  }, [emitTableVisualParamsChange, staticContextRef]);
+  const handleTableHeaderScroll = useCallback((e) => {
+    const {
+      scrollLeft
+    } = e.currentTarget;
+    forceScroll(scrollLeft, scrollableTableSectionRef.current);
+  }, []);
+  const prevScrollTopRef = useRef(0);
+  const handleTableContentScroll = (e) => {
+    const {
+      currentTarget
+    } = e;
+    const horizontalScrollPositionRange = getHorizontalScrollPositionRange(currentTarget);
+    updateRefValue(staticContextRef, {
+      "scrollableTableSectionInfo.horizontalScrollPositionRange": horizontalScrollPositionRange
+    });
+    const {
+      scrollLeft,
+      scrollTop
+    } = currentTarget;
+    if (prevScrollTopRef.current !== scrollTop) {
+      prevScrollTopRef.current = scrollTop;
+      return;
+    }
+    forceScroll(scrollLeft, tableHeaderRef.current);
+    if (!fixColumn) {
+      return;
+    }
+    emitTableVisualParamsChange({
+      horizontalScrollPositionRange
+    });
+  };
+  const firstCallRef = useRef(true);
+  const handleResize = useCallback(() => {
+    if (firstCallRef.current) {
+      firstCallRef.current = false;
+      return;
+    }
+    const scrollableTableSection = scrollableTableSectionRef.current;
+    if (!scrollableTableSection) {
+      return;
+    }
+    const horizontalScrollPositionRange = getHorizontalScrollPositionRange(scrollableTableSection);
+    const verticalScrollBarWidth = getVerticalScrollBarWidth(scrollableTableSection);
+    const {
+      clientWidth
+    } = scrollableTableSection;
+    updateRefValue(staticContextRef, {
+      scrollableTableSectionInfo: {
+        horizontalScrollPositionRange,
+        clientWidth,
+        verticalScrollBarWidth
+      }
+    });
+    emitTableVisualParamsChange({
+      horizontalScrollPositionRange,
+      verticalScrollBarWidth,
+      clientWidth
+    });
+  }, [emitTableVisualParamsChange, staticContextRef]);
+  const handleTableBodyScroll = (e) => {
+    handleTableContentScroll(e);
+    onScroll == null ? void 0 : onScroll(e);
+  };
+  return {
+    onTableContentScroll: handleTableContentScroll,
+    onResize: handleResize,
+    onTableHeaderScroll: handleTableHeaderScroll,
+    onTableBodyScroll: handleTableBodyScroll,
+    scrollableTableSectionRef,
+    tableHeaderRef
+  };
+};
+export {
+  useTableVisualParamsChange
+};

package/dist/components/Table/hooks/useTableVisualParamsChange/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const forceScroll: (scrollLeft: number, target: HTMLElement | null) => void;
+export declare const getHorizontalScrollPositionRange: (el: HTMLElement) => readonly [number, number];
+export declare const getVerticalScrollBarWidth: (el: HTMLElement) => number;

package/dist/components/Table/hooks/useTableVisualParamsChange/utils.js

@@ -0,0 +1,35 @@
+const forceScroll = (scrollLeft, target) => {
+  if (!target || target.scrollLeft === scrollLeft) {
+    return;
+  }
+  target.scrollLeft = scrollLeft;
+  if (target.scrollLeft !== scrollLeft) {
+    setTimeout(() => {
+      target.scrollLeft = scrollLeft;
+    }, 0);
+  }
+};
+const getHorizontalScrollPositionRange = (el) => {
+  const {
+    scrollLeft,
+    scrollWidth,
+    clientWidth
+  } = el;
+  return [scrollLeft, scrollWidth - clientWidth];
+};
+const getVerticalScrollBarWidth = (el) => {
+  const {
+    offsetWidth,
+    clientWidth
+  } = el;
+  const {
+    borderLeftWidth,
+    borderRightWidth
+  } = getComputedStyle(el);
+  return offsetWidth - clientWidth - parseInt(borderLeftWidth) - parseInt(borderRightWidth);
+};
+export {
+  forceScroll,
+  getHorizontalScrollPositionRange,
+  getVerticalScrollBarWidth
+};

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

@@ -0,0 +1,2 @@
+export { Table } from './Table';
+export type { TableProps } from './Table.types';

package/dist/components/Table/interfaces/tableColumns.types.d.ts

@@ -0,0 +1,45 @@
+import { CSSProperties, ReactNode } from 'react';
+import { PropertyPath } from 'lodash-es';
+import { GetComponentProps, GetSingleComponentProps } from './tableComponents.types';
+import { Key } from '../Table.types';
+import { CompareFn, SortOrder } from '../features/tableSort';
+export type ColScopeType = "col" | "colgroup";
+export type RowScopeType = "row" | "rowgroup";
+export type ScopeType = ColScopeType | RowScopeType;
+export type AlignType = "start" | "end" | "left" | "right" | "center" | "justify" | "match-parent";
+interface BaseColumn<Record> {
+    key: Key;
+    dataIndex?: PropertyPath;
+    title?: ReactNode;
+    fixed?: "start" | "end";
+    onHeaderCell?: GetSingleComponentProps<Columns<Record>[number]>;
+    rowScope?: RowScopeType;
+    align?: CSSProperties["textAlign"];
+    ellipsis?: CellEllipsisType;
+    render?: (value: any, record: Record, index: number) => ReactNode;
+    sorter?: boolean | CompareFn<Record>;
+    defaultSortOrder?: SortOrder;
+    sortDirections?: SortOrder[];
+    colSpan?: number;
+    rowSpan?: number;
+}
+export type CellEllipsisType = {
+    showTitle?: boolean;
+} | boolean;
+interface ColumnWithChildrenForbidden {
+    onCell?: never;
+}
+export interface ColumnWithChildren<Record> extends BaseColumn<Record>, ColumnWithChildrenForbidden {
+    children: Columns<Record>;
+}
+export interface Column<Record> extends BaseColumn<Record> {
+    onCell?: GetComponentProps<Record>;
+    width?: number | string;
+    minWidth?: number | string;
+}
+export type Columns<Record> = readonly (ColumnWithChildren<Record> | Column<Record>)[];
+export type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type ColumnsTransformer<Record> = (columns: Writable<Columns<Record>>) => Writable<Columns<Record>>;
+export {};

package/dist/components/Table/interfaces/tableComponents.types.d.ts

@@ -0,0 +1,28 @@
+import { ComponentType, CSSProperties, HTMLAttributes, TdHTMLAttributes, ThHTMLAttributes } from 'react';
+import { CSSInterpolation } from '@emotion/serialize';
+export type CustomizedComponent = keyof JSX.IntrinsicElements | ComponentType;
+export interface TableComponents<C extends CustomizedComponent = CustomizedComponent> {
+    table?: C;
+    header?: {
+        table?: C;
+        wrapper?: C;
+        row?: C;
+        cell?: C;
+    };
+    body?: {
+        wrapper?: C;
+        row?: C;
+        cell?: C;
+    };
+}
+type OverrideAlign<T extends {
+    align?: unknown;
+}> = Omit<T, "align"> & {
+    align?: CSSProperties["textAlign"];
+};
+type WithCss<T> = T & {
+    css?: CSSInterpolation;
+};
+export type GetSingleComponentProps<Data, R extends HTMLAttributes<HTMLElement> = OverrideAlign<ThHTMLAttributes<HTMLTableCellElement>>> = (data: Data) => WithCss<R>;
+export type GetComponentProps<Data, R extends HTMLAttributes<HTMLElement> = OverrideAlign<TdHTMLAttributes<HTMLTableCellElement>>> = (data: Data, index: number) => WithCss<R>;
+export {};

package/dist/components/Table/utils/getRowKey/getRowKey.d.ts

@@ -0,0 +1,2 @@
+import { DefaultRecord } from '../../Table.types';
+export declare const getRowKey: <T extends DefaultRecord>(record: T) => import('react').Key;

package/dist/components/Table/utils/getRowKey/getRowKey.js

@@ -0,0 +1,4 @@
+const getRowKey = (record) => record.key;
+export {
+  getRowKey
+};

package/dist/components/Table/utils/getRowKey/index.d.ts

@@ -0,0 +1,2 @@
+export { getRowKey } from './getRowKey';
+export type { GetRowKey } from './types';

package/dist/components/Table/utils/getRowKey/types.d.ts

@@ -0,0 +1,2 @@
+import { DefaultRecord, Key } from 'components/Table/Table.types';
+export type GetRowKey<Record extends DefaultRecord> = (record: Record) => Key;

package/dist/components/Table/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { updateRefValue, getRefValue } from './ref';
+export { getRowKey, type GetRowKey } from './getRowKey';

package/dist/components/Table/utils/ref/index.d.ts

@@ -0,0 +1 @@
+export { updateRefValue, getRefValue } from './ref';

package/dist/components/Table/utils/ref/ref.d.ts

@@ -0,0 +1,5 @@
+import { MutableRefObject } from 'react';
+import { NestedKeyOf, NestedValueOf, Updates } from './types';
+export declare const updateRefValue: <T extends object>(ref: MutableRefObject<T>, updates: Updates<T>) => void;
+export declare function getRefValue<T extends object>(ref: MutableRefObject<T>): T;
+export declare function getRefValue<T extends object, K extends NestedKeyOf<T>>(ref: MutableRefObject<T>, key: K): NestedValueOf<T, K>;

package/dist/components/Table/utils/ref/ref.js

@@ -0,0 +1,16 @@
+import { set, isUndefined, get } from "lodash-es";
+const updateRefValue = (ref, updates) => {
+  Object.entries(updates).forEach(([key, value]) => {
+    set(ref.current, key, value);
+  });
+};
+function getRefValue(ref, key) {
+  if (isUndefined(key)) {
+    return ref.current;
+  }
+  return get(ref.current, key);
+}
+export {
+  getRefValue,
+  updateRefValue
+};

package/dist/components/Table/utils/ref/types.d.ts

@@ -0,0 +1,10 @@
+export type Updates<T> = Partial<{
+    [K in NestedKeyOf<T>]: NestedValueOf<T, K>;
+}>;
+type Decrement<N extends number> = N extends 0 ? 0 : Tuple<N> extends [unknown, ...infer Rest] ? Rest["length"] : 0;
+type Tuple<N extends number, Acc extends unknown[] = []> = Acc["length"] extends N ? Acc : Tuple<N, [unknown, ...Acc]>;
+export type NestedKeyOf<ObjectType, Depth extends number = 2> = Decrement<Depth> extends infer PrevDepth extends number ? Depth extends 0 ? never : ObjectType extends readonly unknown[] ? never : ObjectType extends object ? {
+    [Key in keyof ObjectType]: `${Key & string}` | `${Key & string}.${NestedKeyOf<ObjectType[Key], PrevDepth>}`;
+}[keyof ObjectType] : never : never;
+export type NestedValueOf<ObjectType, Property extends string> = Property extends `${infer Key}.${infer Rest}` ? Key extends keyof ObjectType ? NestedValueOf<ObjectType[Key], Rest> : never : Property extends keyof ObjectType ? ObjectType[Property] : never;
+export {};

package/dist/hooks/useEvent/index.d.ts

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

package/dist/hooks/useEvent/useEvent.d.ts

@@ -0,0 +1,2 @@
+import { Callback } from './useEvent.types';
+export declare const useEvent: <Args extends readonly unknown[], Return>(callback: Callback<Args, Return>) => Callback<Args, Return>;

package/dist/hooks/useEvent/useEvent.js

@@ -0,0 +1,9 @@
+import { useRef, useCallback } from "react";
+const useEvent = (callback) => {
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  return useCallback((...args) => callbackRef.current(...args), []);
+};
+export {
+  useEvent
+};

package/dist/hooks/useEvent/useEvent.types.d.ts

@@ -0,0 +1 @@
+export type Callback<Args extends readonly unknown[], Return> = (...args: Args) => Return;

package/dist/hooks/useFirstMount/index.d.ts

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

package/dist/hooks/useFirstMount/useFirstMount.d.ts

@@ -0,0 +1 @@
+export declare const useFirstMount: () => boolean;

package/dist/hooks/useFirstMount/useFirstMount.js

@@ -0,0 +1,12 @@
+import { useRef } from "react";
+const useFirstMount = () => {
+  const firstMountRef = useRef(true);
+  if (firstMountRef.current) {
+    firstMountRef.current = false;
+    return true;
+  }
+  return firstMountRef.current;
+};
+export {
+  useFirstMount
+};

package/dist/hooks/useStatic/index.d.ts

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

package/dist/hooks/useStatic/useStatic.d.ts

@@ -0,0 +1 @@
+export declare const useStatic: <T>(init: () => T) => T;

package/dist/hooks/useStatic/useStatic.js

@@ -0,0 +1,8 @@
+import { useRef } from "react";
+const useStatic = (init) => {
+  const ref = useRef(null);
+  return ref.current || (ref.current = init());
+};
+export {
+  useStatic
+};

package/dist/index.d.ts

@@ -49,4 +49,5 @@ export { type EmptyProps, Empty } from './components/Empty';
 export { type SegmentedProps, type SegmentedLabeledOption, Segmented, } from './components/Segmented';
 export { ContextIsolator } from './components/ContextIsolator';
 export { type SpinProps, Spin } from './components/Spin';
+export { type TableProps, Table } from './components/Table';
 export * from 'react-intersection-observer/test-utils';

package/dist/index.js

@@ -37,6 +37,7 @@ import { Empty } from "./components/Empty/Empty.js";
 import { Segmented } from "./components/Segmented/Segmented.js";
 import { ContextIsolator } from "./components/ContextIsolator/ContextIsolator.js";
 import { Spin } from "./components/Spin/Spin.js";
+import { Table } from "./components/Table/Table.js";
 export {
   Alert,
   Avatar,
@@ -60,6 +61,7 @@ export {
   Select,
   Spin,
   Switch,
+  Table,
   Tabs,
   Tag,
   ThemeProvider,

package/dist/utils/eventBus/context/EventBusContext.d.ts

@@ -0,0 +1,2 @@
+import { EventBusContextValue } from './EventBusContext.types';
+export declare const EventBusContext: import('react').Context<EventBusContextValue | null>;

package/dist/utils/eventBus/context/EventBusContext.js

@@ -0,0 +1,5 @@
+import { createContext } from "react";
+const EventBusContext = createContext(null);
+export {
+  EventBusContext
+};

package/dist/utils/eventBus/context/EventBusContext.types.d.ts

@@ -0,0 +1,5 @@
+import { EventBus } from '../eventBus';
+import { EventMap } from '../types';
+export type EventBusContextValue<EM extends EventMap = EventMap> = {
+    bus: EventBus<EM>;
+};

package/dist/utils/eventBus/eventBus.d.ts

@@ -0,0 +1,10 @@
+import { EventCallback, EventMap } from './types';
+export declare class EventBus<EM extends EventMap> {
+    private subscribers;
+    on<K extends keyof EM>(event: K, callback: EventCallback<EM[K]>): () => void;
+    off<K extends keyof EM>(event: K, callback: EventCallback<EM[K]>): void;
+    emit<K extends keyof EM>(event: K, payload: EM[K]): void;
+    subscriberCount<K extends keyof EM>(event: K): number;
+    clearEvent<K extends keyof EM>(event: K): void;
+    clearAll(): void;
+}

package/dist/utils/eventBus/eventBus.js

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class EventBus {
+  constructor() {
+    __publicField(this, "subscribers", {});
+  }
+  on(event, callback) {
+    if (!this.subscribers[event]) {
+      this.subscribers[event] = [];
+    }
+    this.subscribers[event].push(callback);
+    return () => this.off(event, callback);
+  }
+  off(event, callback) {
+    if (!this.subscribers[event]) {
+      return;
+    }
+    this.subscribers[event] = this.subscribers[event].filter((cb) => cb !== callback);
+    if (this.subscribers[event].length === 0) {
+      delete this.subscribers[event];
+    }
+  }
+  emit(event, payload) {
+    var _a;
+    (_a = this.subscribers[event]) == null ? void 0 : _a.forEach((callback) => {
+      try {
+        callback(payload);
+      } catch (error) {
+        console.error(`Ошибка в обработчике события для события ${String(event)}:`, error);
+      }
+    });
+  }
+  subscriberCount(event) {
+    var _a;
+    return ((_a = this.subscribers[event]) == null ? void 0 : _a.length) || 0;
+  }
+  clearEvent(event) {
+    delete this.subscribers[event];
+  }
+  clearAll() {
+    this.subscribers = {};
+  }
+}
+export {
+  EventBus
+};

package/dist/utils/eventBus/hocs/withEventBus/index.d.ts

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

package/dist/utils/eventBus/hocs/withEventBus/withEventBus.d.ts

@@ -0,0 +1,2 @@
+import { FC } from 'react';
+export declare const withEventBus: <T extends FC<any>>(Component: T) => import('react').ForwardRefExoticComponent<Omit<any, "ref"> & import('react').RefAttributes<unknown>>;

package/dist/utils/eventBus/hocs/withEventBus/withEventBus.js

@@ -0,0 +1,15 @@
+import { jsx } from "@emotion/react/jsx-runtime";
+import { forwardRef } from "react";
+import { useStatic } from "../../../../hooks/useStatic/useStatic.js";
+import { EventBus } from "../../eventBus.js";
+import { EventBusProvider } from "../../provider/EventBusProvider.js";
+const withEventBus = (Component) => {
+  const WithEventBus = forwardRef((props, ref) => {
+    const eventBus = useStatic(() => new EventBus());
+    return /* @__PURE__ */ jsx(EventBusProvider, { bus: eventBus, children: /* @__PURE__ */ jsx(Component, { ref, ...props }) });
+  });
+  return WithEventBus;
+};
+export {
+  withEventBus
+};

package/dist/utils/eventBus/hooks/useEmitter/useEmitter.d.ts

@@ -0,0 +1,2 @@
+import { EventMap } from '../../types';
+export declare const defineTypedEmitterHook: <EM extends EventMap>() => <K extends keyof EM>(event: K) => (payload: EM[K]) => void;

package/dist/utils/eventBus/hooks/useEmitter/useEmitter.js

@@ -0,0 +1,8 @@
+import { useEventBus } from "../useEventBus/useEventBus.js";
+const defineTypedEmitterHook = () => (event) => {
+  const bus = useEventBus();
+  return (payload) => bus.emit(event, payload);
+};
+export {
+  defineTypedEmitterHook
+};

package/dist/utils/eventBus/hooks/useEventBus/useEventBus.d.ts

@@ -0,0 +1,3 @@
+import { EventMap } from '../../types';
+import { EventBus } from '../../eventBus';
+export declare const useEventBus: <EM extends EventMap>() => EventBus<EM>;

package/dist/utils/eventBus/hooks/useEventBus/useEventBus.js

@@ -0,0 +1,12 @@
+import { useContext } from "react";
+import { EventBusContext } from "../../context/EventBusContext.js";
+const useEventBus = () => {
+  const context = useContext(EventBusContext);
+  if (!context) {
+    throw new Error("useEventBus должен использоваться внутри EventBusProvider");
+  }
+  return context.bus;
+};
+export {
+  useEventBus
+};