@handsontable/react-wrapper 0.0.0-next-7cc7ef7-20241028

package/dist/src/hotTableContext.d.ts

@@ -0,0 +1,55 @@
+import Handsontable from 'handsontable/base';
+import { ComponentType, FC, PropsWithChildren } from 'react';
+import { ScopeIdentifier, HotRendererProps } from './types';
+import { RenderersPortalManagerRef } from './renderersPortalManager';
+export interface HotTableContextImpl {
+    /**
+     * Map with column indexes (or a string = 'global') as keys, and booleans as values. Each key represents a component-based editor
+     * declared for the used column index, or a global one, if the key is the `global` string.
+     */
+    readonly componentRendererColumns: Map<ScopeIdentifier, boolean>;
+    /**
+     * Array of object containing the column settings.
+     */
+    readonly columnsSettings: Handsontable.ColumnSettings[];
+    /**
+     * Sets the column settings based on information received from HotColumn.
+     *
+     * @param {HotTableProps} columnSettings Column settings object.
+     * @param {Number} columnIndex Column index.
+     */
+    readonly emitColumnSettings: (columnSettings: Handsontable.ColumnSettings, columnIndex: number) => void;
+    /**
+     * Return a renderer wrapper function for the provided renderer component.
+     *
+     * @param {ComponentType<HotRendererProps>} Renderer React renderer component.
+     * @returns {Handsontable.renderers.BaseRenderer} The Handsontable rendering function.
+     */
+    readonly getRendererWrapper: (Renderer: ComponentType<HotRendererProps>) => typeof Handsontable.renderers.BaseRenderer;
+    /**
+     * Clears portals cache.
+     */
+    readonly clearPortalCache: () => void;
+    /**
+     * Clears rendered cells cache.
+     */
+    readonly clearRenderedCellCache: () => void;
+    /**
+     * Set the renderers portal manager dispatch function.
+     *
+     * @param {RenderersPortalManagerRef} pm The PortalManager dispatch function.
+     */
+    readonly setRenderersPortalManagerRef: (pm: RenderersPortalManagerRef) => void;
+    /**
+     * Puts cell portals into portal manager and purges portals cache.
+     */
+    readonly pushCellPortalsIntoPortalManager: () => void;
+}
+declare const HotTableContextProvider: FC<PropsWithChildren>;
+/**
+ * Exposes the table context object to components
+ *
+ * @returns HotTableContext
+ */
+declare function useHotTableContext(): HotTableContextImpl;
+export { HotTableContextProvider, useHotTableContext };

package/dist/src/hotTableInner.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { HotTableProps, HotTableRef } from './types';
+declare const HotTableInner: React.ForwardRefExoticComponent<HotTableProps & React.RefAttributes<HotTableRef>>;
+export default HotTableInner;
+export { HotTableInner };

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './hotColumn';
+export * from './hotTable';
+export { useHotEditor } from './hotEditor';
+export * from './types';
+export { default } from './hotTable';

package/dist/src/renderersPortalManager.d.ts

@@ -0,0 +1,6 @@
+import React, { Dispatch, ReactPortal } from 'react';
+export declare type RenderersPortalManagerRef = Dispatch<ReactPortal[]>;
+/**
+ * Component used to manage the renderer component portals.
+ */
+export declare const RenderersPortalManager: React.ForwardRefExoticComponent<React.RefAttributes<React.Dispatch<React.ReactPortal[]>>>;

package/dist/src/settingsMapper.d.ts

@@ -0,0 +1,18 @@
+import Handsontable from 'handsontable/base';
+import { HotTableProps } from './types';
+export declare class SettingsMapper {
+    /**
+     * Parse component settings into Handsontable-compatible settings.
+     *
+     * @param {Object} properties Object containing properties from the HotTable object.
+     * @param {Object} additionalSettings Additional settings.
+     * @param {boolean} additionalSettings.isInit Flag determining whether the settings are being set during initialization.
+     * @param {string[]} additionalSettings.initOnlySettingKeys Array of keys that can be set only during initialization.
+     * @returns {Object} Handsontable-compatible settings object.
+     */
+    static getSettings(properties: HotTableProps, { prevProps, isInit, initOnlySettingKeys }?: {
+        prevProps?: HotTableProps;
+        isInit?: boolean;
+        initOnlySettingKeys?: Array<keyof Handsontable.GridSettings>;
+    }): Handsontable.GridSettings;
+}

package/dist/src/types.d.ts

@@ -0,0 +1,78 @@
+import Handsontable from 'handsontable/base';
+import { ComponentType, CSSProperties, Dispatch, DispatchWithoutAction, ReactNode } from 'react';
+/**
+ * Type of the identifier under which the cached components are stored.
+ */
+export declare type ScopeIdentifier = 'global' | number;
+/**
+ * Interface for the props of the component-based renderers.
+ */
+export interface HotRendererProps {
+    instance: Handsontable.Core;
+    TD: HTMLTableCellElement;
+    row: number;
+    col: number;
+    prop: string | number;
+    value: any;
+    cellProperties: Handsontable.CellProperties;
+}
+/**
+ * Interface for component-based editor overridden hooks object.
+ */
+export interface HotEditorHooks {
+    onOpen?: () => void;
+    onClose?: () => void;
+    onPrepare?: (row: number, column: number, prop: string | number, TD: HTMLTableCellElement, originalValue: any, cellProperties: Handsontable.CellProperties) => void;
+    onFocus?: () => void;
+}
+/**
+ * Interface for custom component-based editor API exposed by useHotEditor
+ */
+export interface UseHotEditorImpl<T> {
+    value?: T;
+    setValue: Dispatch<T>;
+    isOpen: boolean;
+    finishEditing: DispatchWithoutAction;
+    row?: number;
+    col?: number;
+}
+/**
+ * Helper type to expose GridSettings/ColumnSettings props with native renderers/editors separately
+ *  from component-based render prop.
+ */
+declare type ReplaceRenderersEditors<T extends Pick<Handsontable.GridSettings, 'renderer' | 'editor'>> = Omit<T, 'renderer' | 'editor'> & {
+    hotRenderer?: T['renderer'];
+    renderer?: ComponentType<HotRendererProps>;
+    hotEditor?: T['editor'];
+    editor?: ComponentType;
+};
+/**
+ * Interface for the `prop` of the HotTable component - extending the default Handsontable settings with additional,
+ * component-related properties.
+ */
+export interface HotTableProps extends ReplaceRenderersEditors<Handsontable.GridSettings> {
+    id?: string;
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+/**
+ * Properties related to the HotColumn architecture.
+ */
+export interface HotColumnProps extends ReplaceRenderersEditors<Handsontable.ColumnSettings> {
+    children?: ReactNode;
+}
+/**
+ * Type of interface exposed to parent components by HotTable instance via React ref
+ */
+export interface HotTableRef {
+    /**
+     * Reference to the main Handsontable DOM element.
+     */
+    hotElementRef: HTMLElement;
+    /**
+     * Reference to the Handsontable instance.
+     */
+    hotInstance: Handsontable | null;
+}
+export {};