react-stream-bloc/lib/index.d.ts

React Stream Bloc

import * as React from 'react';
import { ReactElementLike } from 'prop-types';
import { Observable } from 'rxjs';

interface BlocProviderProps {
    children: React.ReactNode;
    providers: ReactElementLike[];
}

declare function BlocProvider({ providers, children }: BlocProviderProps): React.JSX.Element;

type Subscription<S> = (state: S) => void;

declare abstract class Bloc<S> {
    private internalState;
    private listeners;
    constructor(initalState: S);
    get state(): S;
    changeState(state: S): void;
    subscribe(listener: Subscription<S>): void;
    unsubscribe(listener: Subscription<S>): void;
}

declare const getStore: <S>(key: string, session?: boolean, secret_key?: string) => S | null | undefined;
declare const setStore: <S>(key: string, data: S, session?: boolean, secret_key?: string) => boolean;
declare const removeStore: (key: string, session?: boolean) => boolean;
declare const clearStore: (session?: boolean) => boolean;

interface BlocBuilderProps<B extends Bloc<S>, S> {
    bloc: B;
    builder: (state: S) => React.JSX.Element;
}
declare const BlocBuilder: <B extends Bloc<S>, S>({ bloc, builder, }: BlocBuilderProps<B, S>) => React.JSX.Element;

declare enum ConnectionState {
    none = 0,
    waiting = 1,
    active = 2,
    done = 3
}

type Snapshot<T> = ActiveSnapshot<T> | NoneSnapshot<T> | DoneSnapshot<T>;

interface ActiveSnapshot<T> {
    state: ConnectionState.active;
    data: T;
}
interface NoneSnapshot<T> {
    state: ConnectionState.none;
    data: undefined;
}
interface DoneSnapshot<T> {
    state: ConnectionState.done;
    data: undefined;
}
interface StreamBuilderProps<T> {
    stream: Observable<T>;
    builder: (snapshot: Snapshot<T>) => React.ReactNode;
}
interface StreamBuilderState<T> {
    snapshot: Snapshot<T>;
}

declare class StreamBuilder<T> extends React.Component<StreamBuilderProps<T>, StreamBuilderState<T>> {
    private subscription;
    constructor(props: StreamBuilderProps<T>);
    componentDidMount(): void;
    componentWillUnmount(): void;
    render(): React.ReactNode;
}

declare function createContext<T>(): readonly [React.Context<T | undefined>, () => NonNullable<T>];

export { Bloc, BlocBuilder, BlocProvider, StreamBuilder, clearStore, createContext, getStore, removeStore, setStore };