esp-js-react 7.0.2-next.0 → 8.0.0-next.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.dist/esp-react.js +425 -510
- package/.dist/esp-react.js.map +1 -1
- package/.dist/esp-react.min.js +2 -1
- package/.dist/esp-react.min.js.LICENSE.txt +9 -0
- package/.dist/esp-react.min.js.map +1 -1
- package/.dist/typings/connect.d.ts +12 -0
- package/.dist/typings/connectableComponent.d.ts +20 -46
- package/.dist/typings/espModelContext.d.ts +7 -8
- package/.dist/typings/espRouterContext.d.ts +47 -0
- package/.dist/typings/index.d.ts +7 -6
- package/.dist/typings/{getEspReactRenderModel.d.ts → polimer/getEspReactRenderModel.d.ts} +7 -0
- package/.dist/typings/useModelSelector.d.ts +13 -0
- package/.dist/typings/viewBinder.d.ts +1 -8
- package/.dist/typings/viewBinderConnectable.d.ts +15 -0
- package/.dist/typings/viewBindingDecorator.d.ts +1 -2
- package/package.json +7 -6
- package/src/connect.tsx +31 -0
- package/src/connectableComponent.tsx +93 -190
- package/src/espModelContext.tsx +49 -23
- package/src/espRouterContext.tsx +88 -0
- package/src/index.ts +32 -16
- package/src/polimer/getEspReactRenderModel.ts +50 -0
- package/src/useModelSelector.ts +94 -0
- package/src/viewBinder.tsx +14 -22
- package/src/viewBinderConnectable.tsx +53 -0
- package/src/viewBindingDecorator.ts +2 -3
- package/tests/connectWithSelectorTests.tsx +67 -0
- package/tests/connectableComponentLegacyTests.tsx +405 -0
- package/tests/indexTests.ts +0 -12
- package/.dist/typings/routerProvider.d.ts +0 -18
- package/.dist/typings/shallowEqual.d.ts +0 -21
- package/.dist/typings/shouldUpdateMixin.d.ts +0 -10
- package/.dist/typings/smartComponent.d.ts +0 -33
- package/.dist/typings/utils.d.ts +0 -5
- package/src/getEspReactRenderModel.ts +0 -27
- package/src/routerProvider.tsx +0 -47
- package/src/shallowEqual.ts +0 -70
- package/src/shouldUpdateMixin.ts +0 -73
- package/src/smartComponent.tsx +0 -93
- package/src/utils.ts +0 -61
- package/tests/connectableComponentTests.tsx +0 -390
|
@@ -1,61 +1,35 @@
|
|
|
1
1
|
import * as React from 'react';
|
|
2
|
-
import * as PropTypes from 'prop-types';
|
|
3
2
|
import { Router } from 'esp-js';
|
|
4
|
-
|
|
5
|
-
|
|
3
|
+
/**
|
|
4
|
+
* @deprecated
|
|
5
|
+
*/
|
|
6
|
+
export type CreatePublishEventProps<TPublishEventProps> = (publishModelEvent: (eventType: string, event: any) => void) => TPublishEventProps;
|
|
7
|
+
/**
|
|
8
|
+
* @deprecated
|
|
9
|
+
*/
|
|
6
10
|
export type MapModelToProps<TModel, TModelMappedToProps, TPublishEventProps = {}> = (model: TModel, publishEventProps: TPublishEventProps) => TModelMappedToProps;
|
|
7
|
-
|
|
11
|
+
/**
|
|
12
|
+
* @deprecated
|
|
13
|
+
*/
|
|
8
14
|
export interface ConnectableComponentProps<TModel = {}, TPublishEventProps = {}, TModelMappedToProps = {}> {
|
|
9
15
|
modelId?: string;
|
|
10
16
|
viewContext?: string;
|
|
11
|
-
view?:
|
|
12
|
-
/**
|
|
13
|
-
* Provides a means to create a serious of 'publish event' callbacks which will be passed as props to the child view.
|
|
14
|
-
*/
|
|
17
|
+
view?: React.ComponentType;
|
|
15
18
|
createPublishEventProps?: CreatePublishEventProps<TPublishEventProps>;
|
|
16
19
|
mapModelToProps?: MapModelToProps<TModel, TModelMappedToProps, TPublishEventProps>;
|
|
17
20
|
[key: string]: any;
|
|
18
21
|
}
|
|
19
|
-
|
|
22
|
+
/**
|
|
23
|
+
* @deprecated
|
|
24
|
+
*/
|
|
25
|
+
export interface ConnectableComponentChildProps<TModel = object> {
|
|
20
26
|
modelId: string;
|
|
21
27
|
model: TModel;
|
|
22
28
|
router: Router;
|
|
23
29
|
[key: string]: any;
|
|
24
30
|
}
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
}
|
|
31
|
-
interface ConnectableComponentContext {
|
|
32
|
-
router: Router;
|
|
33
|
-
modelId: string;
|
|
34
|
-
}
|
|
35
|
-
export type PublishModelEventDelegate = (eventType: string, event: any) => void;
|
|
36
|
-
export declare class ConnectableComponent<TModel, TPublishEventProps = {}, TModelMappedToProps = {}> extends React.Component<ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>, State> {
|
|
37
|
-
private _isMounted;
|
|
38
|
-
private _observationSubscription;
|
|
39
|
-
context: ConnectableComponentContext;
|
|
40
|
-
static contextTypes: {
|
|
41
|
-
router: PropTypes.Validator<Router>;
|
|
42
|
-
modelId: PropTypes.Requireable<string>;
|
|
43
|
-
};
|
|
44
|
-
constructor(props: ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>, context: ConnectableComponentContext);
|
|
45
|
-
componentWillReceiveProps(nextProps: ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>, nextContext: ConnectableComponentContext): void;
|
|
46
|
-
componentDidMount(): void;
|
|
47
|
-
componentWillUnmount(): void;
|
|
48
|
-
private _getModelId;
|
|
49
|
-
private _tryObserveModel;
|
|
50
|
-
private _tryDisposeModelSubscription;
|
|
51
|
-
private _publishEvent;
|
|
52
|
-
render(): React.JSX.Element;
|
|
53
|
-
private _getChildProps;
|
|
54
|
-
/**
|
|
55
|
-
* Sees if there is a special selector function which can be invoked to return a render model rather than the top level model model itself
|
|
56
|
-
*/
|
|
57
|
-
private _getRenderModel;
|
|
58
|
-
}
|
|
59
|
-
export type ConnectableView = React.ComponentClass | React.SFC;
|
|
60
|
-
export declare const connect: <TModel, TPublishEventProps, TModelMappedToProps = {}>(mapModelToProps?: MapModelToProps<TModel, TModelMappedToProps, TPublishEventProps>, createPublishEventProps?: CreatePublishEventProps<TPublishEventProps>) => (view: ConnectableView) => (props: ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>) => JSX.Element;
|
|
61
|
-
export {};
|
|
31
|
+
/**
|
|
32
|
+
* @deprecated - use ViewBinderConnectable and ESP hooks if you need to dynamically bind a view to a model
|
|
33
|
+
* or useModelSelector with other ESP hooks for direct model subscription.
|
|
34
|
+
*/
|
|
35
|
+
export declare const ConnectableComponent: <TModel = {}, TPublishEventProps = {}, TModelMappedToProps = {}>({ modelId, mapModelToProps, createPublishEventProps, view, viewContext, ...rest }: ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>) => React.JSX.Element;
|
|
@@ -1,18 +1,17 @@
|
|
|
1
1
|
import * as React from 'react';
|
|
2
|
-
import { ModelAddress, Router } from 'esp-js';
|
|
3
2
|
import { PropsWithChildren } from 'react';
|
|
4
3
|
export type GetModelIdDelegate = () => string;
|
|
5
4
|
export declare const GetModelIdContext: React.Context<GetModelIdDelegate>;
|
|
6
5
|
/**
|
|
7
6
|
* Returns a function which will return the ID of the model currently being rendered.
|
|
8
7
|
*/
|
|
9
|
-
export declare const useGetModelId: () =>
|
|
10
|
-
export type
|
|
11
|
-
export declare const
|
|
8
|
+
export declare const useGetModelId: () => string;
|
|
9
|
+
export type GetModelDelegate = <TModel = any>() => TModel;
|
|
10
|
+
export declare const GetModelContext: React.Context<GetModelDelegate>;
|
|
12
11
|
/**
|
|
13
|
-
* Returns a function which
|
|
12
|
+
* Returns a function which will return the model set at last dispatch.
|
|
14
13
|
*/
|
|
15
|
-
export declare const
|
|
14
|
+
export declare const useGetModel: () => any;
|
|
16
15
|
export type PublishModelEventDelegate = (eventType: string, event: any) => void;
|
|
17
16
|
export declare const PublishModelEventContext: React.Context<PublishModelEventDelegate>;
|
|
18
17
|
/**
|
|
@@ -31,6 +30,6 @@ export declare const PublishModelEventWithEntityKeyContext: React.Context<Publis
|
|
|
31
30
|
export declare const usePublishModelEventWithEntityKey: () => PublishModelEventWithEntityKeyDelegate;
|
|
32
31
|
export interface EspModelContextProps {
|
|
33
32
|
modelId: string;
|
|
34
|
-
|
|
33
|
+
model?: unknown;
|
|
35
34
|
}
|
|
36
|
-
export declare const EspModelContext: ({ modelId, children,
|
|
35
|
+
export declare const EspModelContext: ({ modelId, children, model }: PropsWithChildren<EspModelContextProps>) => React.JSX.Element;
|
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
import * as React from 'react';
|
|
2
|
+
import { ModelAddress, Router } from 'esp-js';
|
|
3
|
+
import { PropsWithChildren } from 'react';
|
|
4
|
+
export declare const RouterContext: React.Context<Router>;
|
|
5
|
+
/**
|
|
6
|
+
* Get the esp Router from the RouterContext
|
|
7
|
+
*
|
|
8
|
+
* To use this, please ensure your V-DOM has the EspRouterContext at a higher node:
|
|
9
|
+
*
|
|
10
|
+
* <EspRouterContext router={router}>
|
|
11
|
+
* <YourComponents />
|
|
12
|
+
* </EspRouterContext>
|
|
13
|
+
*/
|
|
14
|
+
export declare const useRouter: () => Router;
|
|
15
|
+
export type PublishEventDelegate = (modelIdOrModelAddress: string | ModelAddress, eventType: string, event: any) => void;
|
|
16
|
+
export declare const PublishEventContext: React.Context<PublishEventDelegate>;
|
|
17
|
+
/**
|
|
18
|
+
* Returns a function which can be used to publish an event.
|
|
19
|
+
*
|
|
20
|
+
* To use this, please ensure your V-DOM has the EspRouterContext at a higher node:
|
|
21
|
+
*
|
|
22
|
+
* <EspRouterContext router={router}>
|
|
23
|
+
* <YourComponents />
|
|
24
|
+
* </EspRouterContext>
|
|
25
|
+
*/
|
|
26
|
+
export declare const usePublishEvent: () => PublishEventDelegate;
|
|
27
|
+
export type EspRouterContextProps = PropsWithChildren<{
|
|
28
|
+
router: Router;
|
|
29
|
+
}>;
|
|
30
|
+
/**
|
|
31
|
+
* Used to set the router on the RouterContext making it available to components down the tree via the useRouter() hook.
|
|
32
|
+
*
|
|
33
|
+
* Also sets up the usePublishEvent() hook so nested components can publish to the router.
|
|
34
|
+
*/
|
|
35
|
+
export declare const EspRouterContext: ({ children, router }: EspRouterContextProps) => React.JSX.Element;
|
|
36
|
+
/**
|
|
37
|
+
* Used to set the router on the RouterContext making it available to components down the tree (via useRouter()).
|
|
38
|
+
*
|
|
39
|
+
* @deprecated use EspRouterContext
|
|
40
|
+
*/
|
|
41
|
+
export declare const RouterProvider: ({ children, router }: EspRouterContextProps) => React.JSX.Element;
|
|
42
|
+
/**
|
|
43
|
+
* Props for RouterProvider
|
|
44
|
+
*
|
|
45
|
+
* @deprecated use EspRouterContextProps
|
|
46
|
+
*/
|
|
47
|
+
export type RouterProviderProps = EspRouterContextProps;
|
package/.dist/typings/index.d.ts
CHANGED
|
@@ -1,10 +1,11 @@
|
|
|
1
1
|
import './polimer/polimerExtentsions';
|
|
2
|
-
export { RouterProvider, RouterContext, useRouter } from './routerProvider';
|
|
3
|
-
export { SmartComponent } from './smartComponent';
|
|
4
2
|
export { ViewBinder } from './viewBinder';
|
|
3
|
+
export { ViewBinderConnectableProps, ViewBinderConnectable } from './viewBinderConnectable';
|
|
5
4
|
export { viewBinding, DEFAULT_VIEW_KEY } from './viewBindingDecorator';
|
|
6
|
-
export
|
|
7
|
-
export { shouldUpdateMixin } from './shouldUpdateMixin';
|
|
5
|
+
export { GetEspReactRenderModelMetadata, GetEspReactRenderModelConsts, getEspReactRenderModel } from './polimer/getEspReactRenderModel';
|
|
8
6
|
export { createViewForModel } from './viewBindingDecorator';
|
|
9
|
-
export {
|
|
10
|
-
export {
|
|
7
|
+
export { connect, ConnectableComponentFactory } from './connect';
|
|
8
|
+
export { CreatePublishEventProps, MapModelToProps, ConnectableComponentProps, ConnectableComponentChildProps, ConnectableComponent, } from './connectableComponent';
|
|
9
|
+
export { useModelSelector, ConnectEqualityFn, defaultConnectEqualityFn } from './useModelSelector';
|
|
10
|
+
export { RouterProvider, RouterProviderProps, EspRouterContext, EspRouterContextProps, RouterContext, useRouter, PublishEventDelegate, PublishEventContext, usePublishEvent, } from './espRouterContext';
|
|
11
|
+
export { useGetModelId, GetModelIdDelegate, GetModelIdContext, PublishModelEventDelegate, PublishModelEventContext, usePublishModelEvent, PublishModelEventWithEntityKeyDelegate, PublishModelEventWithEntityKeyContext, usePublishModelEventWithEntityKey, EspModelContext, EspModelContextProps, } from './espModelContext';
|
|
@@ -12,3 +12,10 @@ export declare namespace GetEspReactRenderModelConsts {
|
|
|
12
12
|
* A decorator which can be used to identify the render model which will replaced the `model` prop passed to the child view of a ConnectableComponent
|
|
13
13
|
*/
|
|
14
14
|
export declare function getEspReactRenderModel(): (target: any, name: any, descriptor: any) => any;
|
|
15
|
+
/**
|
|
16
|
+
* Returns the model which will be used to pluck state/props for the current view.
|
|
17
|
+
*
|
|
18
|
+
* This is basically a hook (not a React 'hook') to call a function on `model` and get a new sub graph to use as state.
|
|
19
|
+
*
|
|
20
|
+
*/
|
|
21
|
+
export declare const tryGetRenderModel: <TRenderModel>(model: any) => TRenderModel;
|
|
@@ -0,0 +1,13 @@
|
|
|
1
|
+
export declare const defaultConnectEqualityFn: <TSelected>(a: TSelected, b: TSelected) => boolean;
|
|
2
|
+
export type ConnectEqualityFn<T> = (last: T, next: T) => boolean;
|
|
3
|
+
/**
|
|
4
|
+
* A hook which returns model state from the esp Router.
|
|
5
|
+
*
|
|
6
|
+
* This hooks wih observe updates and re-render the component if the model changes.
|
|
7
|
+
*
|
|
8
|
+
* @param selector - a function to select a selection of the model - the selector does not need to be memoized, this selector will be cached against the modelId.
|
|
9
|
+
* @param modelId - the modelId of the model to be observed via the esp Router.
|
|
10
|
+
* @param tryPreSelectPolimerImmutableModel - if true, and the esp model is an esp-js-polimer model, the immutable model will be used when calling the selector.
|
|
11
|
+
* @param equalityFn - Equality function which will be applied against TSelected, defaults to instance equality (a === b).
|
|
12
|
+
*/
|
|
13
|
+
export declare const useModelSelector: <TModel = unknown, TSelected = unknown>(selector: (model: TModel) => TSelected, modelId?: string, tryPreSelectPolimerImmutableModel?: boolean, equalityFn?: ConnectEqualityFn<TSelected>) => any;
|
|
@@ -1,13 +1,6 @@
|
|
|
1
|
-
import * as esp from 'esp-js';
|
|
2
1
|
import * as React from 'react';
|
|
3
|
-
import * as PropTypes from 'prop-types';
|
|
4
2
|
export interface ViewBinderProps {
|
|
5
3
|
model: any;
|
|
6
4
|
viewContext: string;
|
|
7
5
|
}
|
|
8
|
-
export declare
|
|
9
|
-
static contextTypes: {
|
|
10
|
-
router: PropTypes.Validator<esp.Router>;
|
|
11
|
-
};
|
|
12
|
-
render(): React.CElement<any, React.Component<any, any, any>>;
|
|
13
|
-
}
|
|
6
|
+
export declare const ViewBinder: React.FC<ViewBinderProps>;
|
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
import * as React from 'react';
|
|
2
|
+
export interface ViewBinderConnectableProps {
|
|
3
|
+
modelId?: string;
|
|
4
|
+
viewContext?: string;
|
|
5
|
+
view?: React.ComponentType;
|
|
6
|
+
}
|
|
7
|
+
/**
|
|
8
|
+
* Dynamically binds a view found via @viewBinder(SomeJsXView) to a model managed by the Router.
|
|
9
|
+
* Optionally provide a view override and/or a viewContext
|
|
10
|
+
* @param modelId
|
|
11
|
+
* @param viewContext
|
|
12
|
+
* @param view
|
|
13
|
+
* @constructor
|
|
14
|
+
*/
|
|
15
|
+
export declare const ViewBinderConnectable: ({ modelId, viewContext, view }: ViewBinderConnectableProps) => React.JSX.Element;
|
|
@@ -1,5 +1,4 @@
|
|
|
1
1
|
import * as React from 'react';
|
|
2
|
-
import { ViewComponentTypes } from './connectableComponent';
|
|
3
2
|
export declare const DEFAULT_VIEW_KEY = "default-view-key";
|
|
4
3
|
/**
|
|
5
4
|
* Tries to get a view for the given model.
|
|
@@ -13,7 +12,7 @@ export declare const DEFAULT_VIEW_KEY = "default-view-key";
|
|
|
13
12
|
* @param displayContext
|
|
14
13
|
* @param view
|
|
15
14
|
*/
|
|
16
|
-
export declare function createViewForModel(model: any, props: any, displayContext: string, view:
|
|
15
|
+
export declare function createViewForModel(model: any, props: any, displayContext: string, view: React.ComponentType): React.ReactElement<{}, string | React.JSXElementConstructor<any>>;
|
|
17
16
|
/**
|
|
18
17
|
* An ES7 style decorator that associates a model with a view
|
|
19
18
|
* @param view the react component that will be used to display this model
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "esp-js-react",
|
|
3
|
-
"version": "
|
|
3
|
+
"version": "8.0.0-next.0",
|
|
4
4
|
"description": "Evented State Processor (ESP) React Components",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"esp",
|
|
@@ -24,10 +24,11 @@
|
|
|
24
24
|
"dev": "nps dev"
|
|
25
25
|
},
|
|
26
26
|
"dependencies": {
|
|
27
|
-
"esp-js": "^
|
|
28
|
-
"esp-js-polimer": "^
|
|
27
|
+
"esp-js": "^8.0.0-next.0",
|
|
28
|
+
"esp-js-polimer": "^8.0.0-next.0",
|
|
29
29
|
"prop-types": "^15.7.2",
|
|
30
|
-
"react": "^
|
|
30
|
+
"react": "^18.3.1",
|
|
31
|
+
"use-sync-external-store": "^1.2.2"
|
|
31
32
|
},
|
|
32
33
|
"devDependencies": {
|
|
33
34
|
"jest": "^29.7.0",
|
|
@@ -40,7 +41,7 @@
|
|
|
40
41
|
"esp-js": "^7.0.0",
|
|
41
42
|
"esp-js-polimer": "^7.0.0",
|
|
42
43
|
"prop-types": "^15.0.0",
|
|
43
|
-
"react": "^
|
|
44
|
+
"react": "^18.0.0"
|
|
44
45
|
},
|
|
45
|
-
"gitHead": "
|
|
46
|
+
"gitHead": "323e76ba03a81860fb027d319eb16b26a1c3e6df"
|
|
46
47
|
}
|
package/src/connect.tsx
ADDED
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
import * as React from 'react';
|
|
2
|
+
import {ConnectableComponent, ConnectableComponentProps, CreatePublishEventProps, MapModelToProps} from './connectableComponent';
|
|
3
|
+
|
|
4
|
+
/**
|
|
5
|
+
* @deprecated
|
|
6
|
+
*/
|
|
7
|
+
export type ConnectableComponentFactory<TModel, TPublishEventProps, TModelMappedToProps = {}> = (view: React.ComponentType) => (props: ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>) => React.JSX.Element;
|
|
8
|
+
|
|
9
|
+
/**
|
|
10
|
+
* @deprecated
|
|
11
|
+
* @param mapModelToProps
|
|
12
|
+
* @param createPublishEventProps
|
|
13
|
+
*/
|
|
14
|
+
export const connect = function <TModel, TPublishEventProps, TModelMappedToProps = {}>(
|
|
15
|
+
mapModelToProps?: MapModelToProps<TModel, TModelMappedToProps, TPublishEventProps>,
|
|
16
|
+
createPublishEventProps?: CreatePublishEventProps<TPublishEventProps>
|
|
17
|
+
): ConnectableComponentFactory<TModel, TPublishEventProps, TModelMappedToProps> {
|
|
18
|
+
return function (view: React.ComponentType) {
|
|
19
|
+
return function (props: ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>) {
|
|
20
|
+
const {modelId, viewContext, ...rest} = props;
|
|
21
|
+
return <ConnectableComponent
|
|
22
|
+
modelId={modelId}
|
|
23
|
+
view={view}
|
|
24
|
+
viewContext={viewContext}
|
|
25
|
+
createPublishEventProps={createPublishEventProps}
|
|
26
|
+
mapModelToProps={mapModelToProps}
|
|
27
|
+
{...rest}
|
|
28
|
+
/>;
|
|
29
|
+
};
|
|
30
|
+
};
|
|
31
|
+
};
|
|
@@ -1,211 +1,114 @@
|
|
|
1
1
|
import * as React from 'react';
|
|
2
|
-
import
|
|
3
|
-
import {
|
|
4
|
-
import {
|
|
5
|
-
import {
|
|
6
|
-
import {
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
2
|
+
import {useRouter} from './espRouterContext';
|
|
3
|
+
import {useMemo} from 'react';
|
|
4
|
+
import {Router, utils} from 'esp-js';
|
|
5
|
+
import {EspModelContext, useGetModelId} from './espModelContext';
|
|
6
|
+
import {createViewForModel} from './viewBindingDecorator';
|
|
7
|
+
import {tryGetRenderModel} from './polimer/getEspReactRenderModel';
|
|
8
|
+
import {useModelSelector} from './useModelSelector';
|
|
9
|
+
|
|
10
|
+
/**
|
|
11
|
+
* @deprecated
|
|
12
|
+
*/
|
|
13
|
+
export type CreatePublishEventProps<TPublishEventProps> = (publishModelEvent: (eventType: string, event: any) => void) => TPublishEventProps;
|
|
14
|
+
|
|
15
|
+
/**
|
|
16
|
+
* @deprecated
|
|
17
|
+
*/
|
|
12
18
|
export type MapModelToProps<TModel, TModelMappedToProps, TPublishEventProps = {}> = (model: TModel, publishEventProps: TPublishEventProps) => TModelMappedToProps;
|
|
13
19
|
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
20
|
+
/**
|
|
21
|
+
* @deprecated
|
|
22
|
+
*/
|
|
23
|
+
export interface ConnectableComponentProps<TModel = {}, TPublishEventProps = {}, TModelMappedToProps = {}> {
|
|
17
24
|
modelId?: string;
|
|
18
25
|
viewContext?: string;
|
|
19
|
-
view?:
|
|
20
|
-
/**
|
|
21
|
-
* Provides a means to create a serious of 'publish event' callbacks which will be passed as props to the child view.
|
|
22
|
-
*/
|
|
26
|
+
view?: React.ComponentType;
|
|
23
27
|
createPublishEventProps?: CreatePublishEventProps<TPublishEventProps>;
|
|
24
28
|
mapModelToProps?: MapModelToProps<TModel, TModelMappedToProps, TPublishEventProps>;
|
|
25
29
|
[key: string]: any; // ...rest props, including the result of mapPublish and mapPublish if 'connect' was used
|
|
26
30
|
}
|
|
27
31
|
|
|
28
|
-
|
|
32
|
+
/**
|
|
33
|
+
* @deprecated
|
|
34
|
+
*/
|
|
35
|
+
export interface ConnectableComponentChildProps<TModel = object> {
|
|
29
36
|
modelId: string;
|
|
30
37
|
model: TModel;
|
|
31
38
|
router: Router;
|
|
32
|
-
[key: string]: any; // ...rest props
|
|
33
|
-
}
|
|
34
|
-
|
|
35
|
-
export interface State {
|
|
36
|
-
model?: any;
|
|
37
|
-
currentModelId?: string;
|
|
38
|
-
publishProps?: any;
|
|
39
|
-
publishEvent?: PublishModelEventDelegate;
|
|
40
|
-
}
|
|
41
|
-
|
|
42
|
-
interface ConnectableComponentContext {
|
|
43
|
-
router: Router;
|
|
44
|
-
modelId: string;
|
|
39
|
+
[key: string]: any; // ...rest props
|
|
45
40
|
}
|
|
46
41
|
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
42
|
+
const getChildProps = <TModel, TModelMappedToProps, TPublishEventProps>(
|
|
43
|
+
router: Router,
|
|
44
|
+
modelId: string,
|
|
45
|
+
restProps: object,
|
|
46
|
+
initialModel: TModel,
|
|
47
|
+
mapModelToProps: MapModelToProps<TModel, TModelMappedToProps, TPublishEventProps>,
|
|
48
|
+
publishEventProps: TPublishEventProps
|
|
49
|
+
): ConnectableComponentChildProps<TModel> => {
|
|
50
|
+
// consume what this component owns, and let the rest end up in `...rest`
|
|
51
|
+
const model = tryGetRenderModel<TModel>(initialModel);
|
|
52
|
+
let childProps = {
|
|
53
|
+
modelId,
|
|
54
|
+
router: router,
|
|
55
|
+
...restProps,
|
|
56
|
+
...publishEventProps,
|
|
57
|
+
model
|
|
57
58
|
};
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
}
|
|
63
|
-
|
|
64
|
-
componentWillReceiveProps(nextProps: ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>, nextContext: ConnectableComponentContext) {
|
|
65
|
-
const modelId = nextProps.modelId || nextContext.modelId;
|
|
66
|
-
const oldModelId = this._getModelId();
|
|
67
|
-
|
|
68
|
-
if (modelId === oldModelId) {
|
|
69
|
-
return;
|
|
70
|
-
}
|
|
71
|
-
|
|
72
|
-
if(nextProps.modelId === oldModelId) {
|
|
73
|
-
return;
|
|
74
|
-
}
|
|
75
|
-
|
|
76
|
-
this._tryObserveModel(modelId);
|
|
77
|
-
}
|
|
78
|
-
|
|
79
|
-
componentDidMount() {
|
|
80
|
-
this._isMounted = true;
|
|
81
|
-
this._tryObserveModel(this._getModelId());
|
|
82
|
-
}
|
|
83
|
-
|
|
84
|
-
componentWillUnmount() {
|
|
85
|
-
this._isMounted = false;
|
|
86
|
-
this._tryDisposeModelSubscription();
|
|
87
|
-
}
|
|
88
|
-
|
|
89
|
-
private _getModelId(): string {
|
|
90
|
-
// props override context
|
|
91
|
-
return this.props.modelId || this.context.modelId;
|
|
92
|
-
}
|
|
93
|
-
|
|
94
|
-
private _tryObserveModel(modelId: string): void {
|
|
95
|
-
this._tryDisposeModelSubscription();
|
|
96
|
-
|
|
97
|
-
if (!modelId) {
|
|
98
|
-
return;
|
|
99
|
-
}
|
|
100
|
-
|
|
101
|
-
let stateChanged = modelId !== this.state.currentModelId;
|
|
102
|
-
|
|
103
|
-
let publishEvent = this.state.publishEvent;
|
|
104
|
-
if (stateChanged) {
|
|
105
|
-
publishEvent = this._publishEvent(this.context.router, modelId);
|
|
106
|
-
}
|
|
107
|
-
|
|
108
|
-
let publishProps = this.state.publishProps;
|
|
109
|
-
// We only map the publish props once, as for well behaving components these callbacks should never change
|
|
110
|
-
if (stateChanged && this.props.createPublishEventProps) {
|
|
111
|
-
publishProps = this.props.createPublishEventProps(publishEvent);
|
|
112
|
-
}
|
|
113
|
-
|
|
114
|
-
if (stateChanged) {
|
|
115
|
-
this.setState({
|
|
116
|
-
currentModelId: modelId,
|
|
117
|
-
publishEvent,
|
|
118
|
-
publishProps
|
|
119
|
-
});
|
|
120
|
-
this._observationSubscription = this.context.router
|
|
121
|
-
.getModelObservable(modelId)
|
|
122
|
-
.subscribe(model => {
|
|
123
|
-
if (this._isMounted) {
|
|
124
|
-
this.setState({model});
|
|
125
|
-
}
|
|
126
|
-
});
|
|
127
|
-
}
|
|
128
|
-
}
|
|
129
|
-
|
|
130
|
-
private _tryDisposeModelSubscription() {
|
|
131
|
-
if(this._observationSubscription) {
|
|
132
|
-
this._observationSubscription.dispose();
|
|
133
|
-
this._observationSubscription = new DisposableBase();
|
|
134
|
-
this.setState({model: null, currentModelId: null, publishProps: null, publishEvent: null});
|
|
135
|
-
}
|
|
136
|
-
}
|
|
137
|
-
|
|
138
|
-
private _publishEvent = (router: Router, modelId: string) => (eventType: string, event: any) => router.publishEvent(modelId, eventType, event);
|
|
139
|
-
|
|
140
|
-
public render() {
|
|
141
|
-
if(this.state.model == null) {
|
|
142
|
-
return null;
|
|
143
|
-
}
|
|
144
|
-
let childProps = this._getChildProps();
|
|
145
|
-
let view = createViewForModel(this.state.model, childProps, this.props.viewContext, this.props.view);
|
|
146
|
-
|
|
147
|
-
return (<EspModelContext modelId={this.props.modelId} router={this.context.router} {...childProps}>{view}</EspModelContext>);
|
|
148
|
-
}
|
|
149
|
-
|
|
150
|
-
private _getChildProps(): ConnectableComponentChildProps<TModel> {
|
|
151
|
-
// consume what this component owns, and let the rest end up in `...rest`
|
|
152
|
-
const {children, createPublishEventProps, modelId, mapModelToProps, view, viewContext, ...rest} = this.props;
|
|
153
|
-
const model = this._getRenderModel(this.state.model);
|
|
154
|
-
let childProps = {
|
|
155
|
-
modelId,
|
|
156
|
-
router: this.context.router,
|
|
157
|
-
...rest,
|
|
158
|
-
...this.state.publishProps,
|
|
159
|
-
model
|
|
59
|
+
if (mapModelToProps) {
|
|
60
|
+
childProps = {
|
|
61
|
+
...childProps,
|
|
62
|
+
...(mapModelToProps(model, publishEventProps) as TModelMappedToProps)
|
|
160
63
|
};
|
|
161
|
-
if (this.props.mapModelToProps) {
|
|
162
|
-
childProps = {
|
|
163
|
-
...childProps,
|
|
164
|
-
...(this.props.mapModelToProps(model, this.state.publishProps) as any)
|
|
165
|
-
};
|
|
166
|
-
}
|
|
167
|
-
return childProps;
|
|
168
64
|
}
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
65
|
+
return childProps;
|
|
66
|
+
};
|
|
67
|
+
|
|
68
|
+
/**
|
|
69
|
+
* @deprecated - use ViewBinderConnectable and ESP hooks if you need to dynamically bind a view to a model
|
|
70
|
+
* or useModelSelector with other ESP hooks for direct model subscription.
|
|
71
|
+
*/
|
|
72
|
+
export const ConnectableComponent = <TModel = {}, TPublishEventProps = {}, TModelMappedToProps = {}>(
|
|
73
|
+
{
|
|
74
|
+
modelId,
|
|
75
|
+
mapModelToProps,
|
|
76
|
+
createPublishEventProps,
|
|
77
|
+
view,
|
|
78
|
+
viewContext,
|
|
79
|
+
...rest
|
|
80
|
+
}: ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>
|
|
81
|
+
) => {
|
|
82
|
+
const router = useRouter();
|
|
83
|
+
modelId = modelId || useGetModelId();
|
|
84
|
+
if (utils.stringIsEmpty(modelId) || !router) {
|
|
85
|
+
return null;
|
|
86
|
+
}
|
|
87
|
+
const publishEventProps: TPublishEventProps = useMemo(
|
|
88
|
+
() => {
|
|
89
|
+
if (createPublishEventProps) {
|
|
90
|
+
const publishModelEvent = (eventType: string, event: any) => {
|
|
91
|
+
router.publishEvent(modelId, eventType, event);
|
|
92
|
+
};
|
|
93
|
+
return createPublishEventProps(publishModelEvent);
|
|
179
94
|
}
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
95
|
+
return {} as TPublishEventProps;
|
|
96
|
+
},
|
|
97
|
+
[router, modelId]
|
|
98
|
+
);
|
|
99
|
+
const model = useModelSelector<TModel, TModel>(
|
|
100
|
+
m => m,
|
|
101
|
+
modelId,
|
|
102
|
+
false
|
|
103
|
+
);
|
|
104
|
+
if (model == null) {
|
|
105
|
+
return null;
|
|
188
106
|
}
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
createPublishEventProps?: CreatePublishEventProps<TPublishEventProps>
|
|
197
|
-
): (view: ConnectableView) => (props: ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>) => JSX.Element {
|
|
198
|
-
return function(view: ConnectableView) {
|
|
199
|
-
return function(props: ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>) {
|
|
200
|
-
const {modelId, viewContext, ...rest} = props;
|
|
201
|
-
return <ConnectableComponent
|
|
202
|
-
modelId={modelId}
|
|
203
|
-
view={view}
|
|
204
|
-
viewContext={viewContext}
|
|
205
|
-
createPublishEventProps={createPublishEventProps}
|
|
206
|
-
mapModelToProps={mapModelToProps}
|
|
207
|
-
{...rest}
|
|
208
|
-
/>;
|
|
209
|
-
};
|
|
210
|
-
};
|
|
107
|
+
let childProps = getChildProps(router, modelId, rest, model, mapModelToProps, publishEventProps);
|
|
108
|
+
let viewElement = createViewForModel(model, childProps, viewContext, view);
|
|
109
|
+
return (
|
|
110
|
+
<EspModelContext modelId={modelId} model={model} router={router} {...childProps}>
|
|
111
|
+
{viewElement}
|
|
112
|
+
</EspModelContext>
|
|
113
|
+
);
|
|
211
114
|
};
|