@intuitionrobotics/thunderstorm
Version:
96 lines (95 loc) • 4.23 kB
TypeScript
import * as React from "react";
import { ComponentType } from "react";
import { _BaseNodeRenderer, BaseRendererMap, NodeRendererProps, TreeRendererMap } from "./BaseRenderer";
import { TreeNode } from "../tree/types";
export type InferItemType<R> = R extends React.ComponentType<{
item: infer Item1;
node: TreeNode;
}> ? Item1 : R extends React.ComponentType<{
item: infer Item;
}> ? Item : "Make sure the Renderer renders the correct item type e.g. (props:{item:Item, node: TreeNode}) => React.ReactNode";
export type FlatItemToRender<Rm extends BaseRendererMap<any>, K extends keyof Rm = keyof Rm, Item = InferItemType<Rm[K]>> = {
item: Item;
type: K;
};
export type ItemToRender<Rm extends BaseRendererMap<any>, K extends keyof Rm = keyof Rm, Item = InferItemType<Rm[K]>> = FlatItemToRender<Rm, K> & {
_children?: ItemToRender<Rm>[];
};
export type _GenericRenderer<Rm extends BaseRendererMap<any>, ItemType extends ItemToRender<Rm> = ItemToRender<Rm>> = {
rendererMap: Rm;
items: ItemType[];
};
export declare class BaseAdapter<T = any, R extends React.ComponentType<T> = React.ComponentType<T>> {
data: any;
constructor(data: any);
setData(data: object): this;
filter<K>(obj: K, key: keyof K): boolean;
getChildren: <K extends object>(obj: K) => (keyof K)[];
isParent: (obj: any) => boolean;
getFilteredChildren<K>(obj: K): (keyof K)[] | [];
adjust(obj: any): {
data: any;
deltaPath?: string;
};
clone(baseAdapter: this): this;
}
export declare class Adapter<T = any, I extends NodeRendererProps<T> = NodeRendererProps<T>> extends BaseAdapter<I> {
hideRoot: boolean;
treeNodeRenderer: _BaseNodeRenderer<any>;
setTreeNodeRenderer(renderer: any): this;
resolveRenderer(propKey: string): _BaseNodeRenderer<I>;
}
type NestedType<T = any> = {
item: T;
_children: NestedObjectOfType<T>[];
};
type NestedObjectOfType<T = any> = T | NestedType<T>;
type ListData<I> = I[];
type AdapterData<D> = D | (() => D);
declare class BaseAdapterBuilder<I, Data> {
data: Data;
treeNodeRenderer: ComponentType<NodeRendererProps<I>>;
getChildrenKeys: (obj: any) => (any[]);
isParent: (obj: any) => (boolean);
adjust: ((obj: any) => {
data: any;
deltaPath: string;
});
setData(data: Data): this;
}
declare class ListSingleAdapterBuilder<ItemType = any> extends BaseAdapterBuilder<ItemType, AdapterData<ListData<ItemType>>> {
readonly renderer: _BaseNodeRenderer<ItemType>;
constructor(renderer: _BaseNodeRenderer<ItemType>);
nested(): ListSingleAdapterBuilder<NestedObjectOfType<ItemType>>;
build(): Adapter<any, NodeRendererProps<any>>;
}
declare class ListMultiAdapterBuilder<Rm extends TreeRendererMap, ItemType extends FlatItemToRender<Rm> = FlatItemToRender<Rm>> extends BaseAdapterBuilder<ItemType, AdapterData<ListData<ItemType>>> {
readonly rendererMap: Rm;
constructor(rendererMap: Rm);
nested(): ListMultiAdapterBuilder<Rm, ItemToRender<Rm>>;
noGeneralOnClick(): ListMultiAdapterBuilder<Rm, ItemToRender<Rm>>;
build(): Adapter<any, NodeRendererProps<any>>;
}
type NestedTreeData<I> = {
[k: string]: I | TreeData<I>;
};
type TreeData<I> = NestedTreeData<I>;
declare class TreeSingleAdapterBuilder<RenderItemType = any> extends BaseAdapterBuilder<RenderItemType, AdapterData<TreeData<RenderItemType>>> {
readonly renderer: _BaseNodeRenderer<RenderItemType>;
constructor(renderer: _BaseNodeRenderer<RenderItemType>);
treeNodeRenderer: (props: NodeRendererProps<RenderItemType>) => React.JSX.Element;
build(): Adapter<any, NodeRendererProps<any>>;
}
declare class ListAdapterBuilder {
singleRender<Item>(renderer: _BaseNodeRenderer<Item>): ListSingleAdapterBuilder<Item>;
multiRender<Rm extends TreeRendererMap>(rendererMap: Rm): ListMultiAdapterBuilder<Rm, FlatItemToRender<Rm, keyof Rm, InferItemType<Rm[keyof Rm]>>>;
}
declare class TreeAdapterBuilder {
singleRender<Item>(renderer: _BaseNodeRenderer<Item>): TreeSingleAdapterBuilder<Item>;
}
declare class MainAdapterBuilder {
list(): ListAdapterBuilder;
tree(): TreeAdapterBuilder;
}
export declare function AdapterBuilder(): MainAdapterBuilder;
export {};