esp-js-react 7.0.2 → 8.0.1-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 +468 -511
- 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 → espModelContextProvider.d.ts} +8 -9
- package/.dist/typings/espRouterContextProvider.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 +27 -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 +94 -190
- package/src/espModelContextProvider.tsx +95 -0
- package/src/espRouterContextProvider.tsx +88 -0
- package/src/index.ts +40 -18
- package/src/polimer/getEspReactRenderModel.ts +50 -0
- package/src/useModelSelector.ts +159 -0
- package/src/viewBinder.tsx +14 -22
- package/src/viewBinderConnectable.tsx +54 -0
- package/src/viewBindingDecorator.ts +2 -3
- package/tests/connectableComponentLegacyTests.tsx +405 -0
- package/tests/indexTests.ts +0 -12
- package/tests/routerSpy.ts +24 -0
- package/tests/useModelSelectorTests.tsx +361 -0
- 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/espModelContext.tsx +0 -69
- 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,211 +1,115 @@
|
|
|
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 './espRouterContextProvider';
|
|
3
|
+
import {useMemo} from 'react';
|
|
4
|
+
import {Router, utils} from 'esp-js';
|
|
5
|
+
import {EspModelContextProvider, useGetModelId} from './espModelContextProvider';
|
|
6
|
+
import {createViewForModel} from './viewBindingDecorator';
|
|
7
|
+
import {tryGetRenderModel} from './polimer/getEspReactRenderModel';
|
|
8
|
+
import {modelSelectorOptions, 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
|
+
modelSelectorOptions()
|
|
102
|
+
.setModelId(modelId)
|
|
103
|
+
.setTryPreSelectPolimerImmutableModel(false)
|
|
104
|
+
);
|
|
105
|
+
if (model == null) {
|
|
106
|
+
return null;
|
|
188
107
|
}
|
|
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
|
-
};
|
|
108
|
+
let childProps = getChildProps(router, modelId, rest, model, mapModelToProps, publishEventProps);
|
|
109
|
+
let viewElement = createViewForModel(model, childProps, viewContext, view);
|
|
110
|
+
return (
|
|
111
|
+
<EspModelContextProvider modelId={modelId} model={model} router={router} {...childProps}>
|
|
112
|
+
{viewElement}
|
|
113
|
+
</EspModelContextProvider>
|
|
114
|
+
);
|
|
211
115
|
};
|
|
@@ -0,0 +1,95 @@
|
|
|
1
|
+
import * as React from 'react';
|
|
2
|
+
import {DefaultModelAddress, Router, Status, Logger, utils} from 'esp-js';
|
|
3
|
+
import {useContext, useCallback, createContext, PropsWithChildren} from 'react';
|
|
4
|
+
import {useRouter} from './espRouterContextProvider';
|
|
5
|
+
|
|
6
|
+
const _log = Logger.create('EspModelContextProvider');
|
|
7
|
+
|
|
8
|
+
export type GetModelIdDelegate = () => string;
|
|
9
|
+
export const GetModelIdContext = createContext<GetModelIdDelegate>(null);
|
|
10
|
+
/**
|
|
11
|
+
* Returns a function which will return the ID of the model currently being rendered.
|
|
12
|
+
*/
|
|
13
|
+
export const useGetModelId = () => useContext(GetModelIdContext)();
|
|
14
|
+
|
|
15
|
+
export type GetModelDelegate = <TModel = any, >() => TModel;
|
|
16
|
+
export const GetModelContext = createContext<GetModelDelegate>(null);
|
|
17
|
+
/**
|
|
18
|
+
* Returns a function which will return the model set at last dispatch.
|
|
19
|
+
*/
|
|
20
|
+
export const useGetModel = () => useContext(GetModelContext)();
|
|
21
|
+
|
|
22
|
+
export type PublishModelEventDelegate = (eventType: string, event: any) => void;
|
|
23
|
+
export const PublishModelEventContext = createContext<PublishModelEventDelegate>(null);
|
|
24
|
+
/**
|
|
25
|
+
* Returns a function which can be used to publish an event to the current model being rendered.
|
|
26
|
+
*
|
|
27
|
+
* Effectively, this is a version of usePublishEvent() which closes over the current modelId.
|
|
28
|
+
*/
|
|
29
|
+
export const usePublishModelEvent = () => useContext(PublishModelEventContext);
|
|
30
|
+
|
|
31
|
+
export type PublishModelEventWithEntityKeyDelegate = (entityKey: string, eventType: string, event: any) => void;
|
|
32
|
+
export const PublishModelEventWithEntityKeyContext = createContext<PublishModelEventWithEntityKeyDelegate>(null);
|
|
33
|
+
/**
|
|
34
|
+
* Returns a function which can be used to publish an event to the current model being rendered, allows an entityKey to be specified.
|
|
35
|
+
*
|
|
36
|
+
* Effectively, this is a version of usePublishEvent() which closes over the current modelId.
|
|
37
|
+
*/
|
|
38
|
+
export const usePublishModelEventWithEntityKey = () => useContext(PublishModelEventWithEntityKeyContext);
|
|
39
|
+
|
|
40
|
+
export interface EspModelContextProviderProps {
|
|
41
|
+
modelId: string;
|
|
42
|
+
model?: unknown;
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
export const EspModelContextProvider = ({modelId, children, model}: PropsWithChildren<EspModelContextProviderProps>) => {
|
|
46
|
+
const router = useRouter();
|
|
47
|
+
const getModelId: () => string = useCallback(() => {
|
|
48
|
+
return modelId;
|
|
49
|
+
}, [router, modelId]);
|
|
50
|
+
const getModel: () => any = useCallback(() => {
|
|
51
|
+
warnIfModelAccessedOutSideDispatchLoop(router, modelId);
|
|
52
|
+
return model;
|
|
53
|
+
}, [model, router, modelId]);
|
|
54
|
+
const publishModelEvent: PublishModelEventDelegate = useCallback((eventType: string, event: any) => {
|
|
55
|
+
router.publishEvent(modelId, eventType, event);
|
|
56
|
+
}, [router, modelId]);
|
|
57
|
+
const publishModelEventWithEntityKey: PublishModelEventWithEntityKeyDelegate = useCallback((entityKey: string, eventType: string, event: any) => {
|
|
58
|
+
router.publishEvent(new DefaultModelAddress(modelId, entityKey), eventType, event);
|
|
59
|
+
}, [router, modelId]);
|
|
60
|
+
return (
|
|
61
|
+
<GetModelIdContext.Provider value={getModelId}>
|
|
62
|
+
<PublishModelEventContext.Provider value={publishModelEvent}>
|
|
63
|
+
<PublishModelEventWithEntityKeyContext.Provider value={publishModelEventWithEntityKey}>
|
|
64
|
+
<GetModelContext.Provider value={getModel}>
|
|
65
|
+
{children}
|
|
66
|
+
</GetModelContext.Provider>
|
|
67
|
+
</PublishModelEventWithEntityKeyContext.Provider>
|
|
68
|
+
</PublishModelEventContext.Provider>
|
|
69
|
+
</GetModelIdContext.Provider>
|
|
70
|
+
);
|
|
71
|
+
};
|
|
72
|
+
|
|
73
|
+
const warnIfModelAccessedOutSideDispatchLoop = (router: Router, modelId: string) => {
|
|
74
|
+
if (process.env.NODE_ENV === 'production') {
|
|
75
|
+
return;
|
|
76
|
+
}
|
|
77
|
+
if (utils.stringIsEmpty(modelId)) {
|
|
78
|
+
return;
|
|
79
|
+
}
|
|
80
|
+
let isDispatchModelUpdateStatus = router.isModelDispatchStatus(modelId, Status.DispatchModelUpdates);
|
|
81
|
+
if (!isDispatchModelUpdateStatus) {
|
|
82
|
+
let stack: string | undefined = undefined;
|
|
83
|
+
try {
|
|
84
|
+
// noinspection ExceptionCaughtLocallyJS
|
|
85
|
+
throw new Error();
|
|
86
|
+
} catch (e) {
|
|
87
|
+
stack = (e as Error).stack;
|
|
88
|
+
}
|
|
89
|
+
_log.warn(
|
|
90
|
+
`EspModelContextProvider useGetModelId has been invoked outside of the models (${modelId}) dispatch loop.` +
|
|
91
|
+
`This may have unknown state state issues.` +
|
|
92
|
+
stack
|
|
93
|
+
);
|
|
94
|
+
}
|
|
95
|
+
};
|
|
@@ -0,0 +1,88 @@
|
|
|
1
|
+
// notice_start
|
|
2
|
+
/*
|
|
3
|
+
* Copyright 2015 Dev Shop Limited
|
|
4
|
+
*
|
|
5
|
+
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
6
|
+
* you may not use this file except in compliance with the License.
|
|
7
|
+
* You may obtain a copy of the License at
|
|
8
|
+
*
|
|
9
|
+
* http://www.apache.org/licenses/LICENSE-2.0
|
|
10
|
+
*
|
|
11
|
+
* Unless required by applicable law or agreed to in writing, software
|
|
12
|
+
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
13
|
+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
14
|
+
* See the License for the specific language governing permissions and
|
|
15
|
+
* limitations under the License.
|
|
16
|
+
*/
|
|
17
|
+
// notice_end
|
|
18
|
+
|
|
19
|
+
import * as React from 'react';
|
|
20
|
+
import {ModelAddress, Router} from 'esp-js';
|
|
21
|
+
import {PropsWithChildren, createContext, useContext, useCallback} from 'react';
|
|
22
|
+
|
|
23
|
+
export const RouterContext = createContext<Router>(null);
|
|
24
|
+
|
|
25
|
+
/**
|
|
26
|
+
* Get the esp Router from the RouterContext
|
|
27
|
+
*
|
|
28
|
+
* To use this, please ensure your V-DOM has the EspRouterContext at a higher node:
|
|
29
|
+
*
|
|
30
|
+
* <EspRouterContext router={router}>
|
|
31
|
+
* <YourComponents />
|
|
32
|
+
* </EspRouterContext>
|
|
33
|
+
*/
|
|
34
|
+
export const useRouter = () => {
|
|
35
|
+
const context: Router = useContext(RouterContext);
|
|
36
|
+
if (context === undefined) {
|
|
37
|
+
throw new Error('useRouter must be used within a RouterContext.Provider');
|
|
38
|
+
}
|
|
39
|
+
return context;
|
|
40
|
+
};
|
|
41
|
+
|
|
42
|
+
export type PublishEventDelegate = (modelIdOrModelAddress: string | ModelAddress, eventType: string, event: any) => void;
|
|
43
|
+
export const PublishEventContext = createContext<PublishEventDelegate>(null);
|
|
44
|
+
|
|
45
|
+
/**
|
|
46
|
+
* Returns a function which can be used to publish an event.
|
|
47
|
+
*
|
|
48
|
+
* To use this, please ensure your V-DOM has the EspRouterContext at a higher node:
|
|
49
|
+
*
|
|
50
|
+
* <EspRouterContextProvider router={router}>
|
|
51
|
+
* <YourComponents />
|
|
52
|
+
* </EspRouterContextProvider>
|
|
53
|
+
*/
|
|
54
|
+
export const usePublishEvent = () => useContext(PublishEventContext);
|
|
55
|
+
|
|
56
|
+
export type EspRouterContextProviderProps = PropsWithChildren<{ router: Router; }>;
|
|
57
|
+
|
|
58
|
+
/**
|
|
59
|
+
* Used to set the router on the RouterContext making it available to components down the tree via the useRouter() hook.
|
|
60
|
+
*
|
|
61
|
+
* Also sets up the usePublishEvent() hook so nested components can publish to the router.
|
|
62
|
+
*/
|
|
63
|
+
export const EspRouterContextProvider = ({children, router}: EspRouterContextProviderProps) => {
|
|
64
|
+
const publishEvent: PublishEventDelegate = useCallback((modelIdOrModelAddress: string, eventType: string, event: any) => {
|
|
65
|
+
router.publishEvent(modelIdOrModelAddress, eventType, event);
|
|
66
|
+
}, [router]);
|
|
67
|
+
return (
|
|
68
|
+
<RouterContext.Provider value={router}>
|
|
69
|
+
<PublishEventContext.Provider value={publishEvent}>
|
|
70
|
+
{children}
|
|
71
|
+
</PublishEventContext.Provider>
|
|
72
|
+
</RouterContext.Provider>
|
|
73
|
+
);
|
|
74
|
+
};
|
|
75
|
+
|
|
76
|
+
/**
|
|
77
|
+
* Used to set the router on the RouterContext making it available to components down the tree (via useRouter()).
|
|
78
|
+
*
|
|
79
|
+
* @deprecated use EspRouterContextProvider
|
|
80
|
+
*/
|
|
81
|
+
export const RouterProvider = EspRouterContextProvider;
|
|
82
|
+
|
|
83
|
+
/**
|
|
84
|
+
* Props for RouterProvider
|
|
85
|
+
*
|
|
86
|
+
* @deprecated use EspRouterContextProviderProps
|
|
87
|
+
*/
|
|
88
|
+
export type RouterProviderProps = EspRouterContextProviderProps;
|
package/src/index.ts
CHANGED
|
@@ -20,39 +20,61 @@
|
|
|
20
20
|
// import for side effects
|
|
21
21
|
import './polimer/polimerExtentsions';
|
|
22
22
|
|
|
23
|
-
export {RouterProvider, RouterContext, useRouter} from './routerProvider';
|
|
24
|
-
export {SmartComponent} from './smartComponent';
|
|
25
23
|
export {ViewBinder} from './viewBinder';
|
|
24
|
+
export {
|
|
25
|
+
ViewBinderConnectableProps,
|
|
26
|
+
ViewBinderConnectable
|
|
27
|
+
} from './viewBinderConnectable';
|
|
26
28
|
export {viewBinding, DEFAULT_VIEW_KEY} from './viewBindingDecorator';
|
|
27
|
-
export
|
|
28
|
-
|
|
29
|
+
export {
|
|
30
|
+
GetEspReactRenderModelMetadata,
|
|
31
|
+
GetEspReactRenderModelConsts,
|
|
32
|
+
getEspReactRenderModel
|
|
33
|
+
} from './polimer/getEspReactRenderModel';
|
|
29
34
|
export {createViewForModel} from './viewBindingDecorator';
|
|
30
35
|
export {
|
|
31
|
-
ConnectableComponent,
|
|
32
36
|
connect,
|
|
33
|
-
|
|
34
|
-
|
|
37
|
+
ConnectableComponentFactory
|
|
38
|
+
} from './connect';
|
|
39
|
+
export {
|
|
35
40
|
CreatePublishEventProps,
|
|
36
|
-
|
|
41
|
+
MapModelToProps,
|
|
42
|
+
ConnectableComponentProps,
|
|
37
43
|
ConnectableComponentChildProps,
|
|
44
|
+
ConnectableComponent,
|
|
38
45
|
} from './connectableComponent';
|
|
39
46
|
export {
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
47
|
+
UseModelSelector,
|
|
48
|
+
useModelSelector,
|
|
49
|
+
EditableModelSelectorOptions,
|
|
50
|
+
modelSelectorOptions,
|
|
51
|
+
ModelSelectorOptions,
|
|
52
|
+
ModelSelectorEqualityFn,
|
|
53
|
+
} from './useModelSelector';
|
|
54
|
+
export {
|
|
55
|
+
RouterProvider,
|
|
56
|
+
RouterProviderProps,
|
|
57
|
+
EspRouterContextProvider,
|
|
58
|
+
EspRouterContextProviderProps,
|
|
59
|
+
RouterContext,
|
|
60
|
+
useRouter,
|
|
44
61
|
PublishEventDelegate,
|
|
45
62
|
PublishEventContext,
|
|
46
63
|
usePublishEvent,
|
|
47
|
-
|
|
64
|
+
} from './espRouterContextProvider';
|
|
65
|
+
export {
|
|
66
|
+
useGetModelId,
|
|
67
|
+
GetModelIdDelegate,
|
|
68
|
+
GetModelIdContext,
|
|
69
|
+
useGetModel,
|
|
70
|
+
GetModelDelegate,
|
|
71
|
+
GetModelContext,
|
|
48
72
|
PublishModelEventDelegate,
|
|
49
73
|
PublishModelEventContext,
|
|
50
74
|
usePublishModelEvent,
|
|
51
|
-
|
|
52
75
|
PublishModelEventWithEntityKeyDelegate,
|
|
53
76
|
PublishModelEventWithEntityKeyContext,
|
|
54
77
|
usePublishModelEventWithEntityKey,
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
} from './espModelContext';
|
|
78
|
+
EspModelContextProvider,
|
|
79
|
+
EspModelContextProviderProps,
|
|
80
|
+
} from './espModelContextProvider';
|
|
@@ -0,0 +1,50 @@
|
|
|
1
|
+
import {EspMetadata, EspDecoratorUtil, utils} from 'esp-js';
|
|
2
|
+
|
|
3
|
+
export interface GetEspReactRenderModelMetadata {
|
|
4
|
+
functionName: string;
|
|
5
|
+
}
|
|
6
|
+
|
|
7
|
+
export namespace GetEspReactRenderModelConsts {
|
|
8
|
+
export const CustomDataKey = 'GetEspReactRenderModelCustomDataKey';
|
|
9
|
+
/**
|
|
10
|
+
* If there is no @getEspReactRenderModel decorator and a function by this name exists on a model, then it will be invoked to identify the sub model which will replaced the `model` prop passed to the child view of a ConnectableComponent
|
|
11
|
+
*/
|
|
12
|
+
export const HandlerFunctionName = 'getEspReactRenderModel';
|
|
13
|
+
}
|
|
14
|
+
|
|
15
|
+
/**
|
|
16
|
+
* 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
|
|
17
|
+
*/
|
|
18
|
+
export function getEspReactRenderModel() {
|
|
19
|
+
return function (target, name, descriptor) {
|
|
20
|
+
let metadata: EspMetadata = EspDecoratorUtil.getOrCreateMetaData(target.constructor);
|
|
21
|
+
metadata.addCustomData(
|
|
22
|
+
GetEspReactRenderModelConsts.CustomDataKey,
|
|
23
|
+
<GetEspReactRenderModelMetadata>{ functionName: name }
|
|
24
|
+
);
|
|
25
|
+
return descriptor;
|
|
26
|
+
};
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
/**
|
|
30
|
+
* Returns the model which will be used to pluck state/props for the current view.
|
|
31
|
+
*
|
|
32
|
+
* This is basically a hook (not a React 'hook') to call a function on `model` and get a new subgraph to use as state.
|
|
33
|
+
*
|
|
34
|
+
*/
|
|
35
|
+
export const tryGetRenderModel = <TRenderModel>(model: any): TRenderModel => {
|
|
36
|
+
// does the given model have a decorated function we can invoke to get a different model to render?
|
|
37
|
+
if (EspDecoratorUtil.hasMetadata(model)) {
|
|
38
|
+
let metadata: GetEspReactRenderModelMetadata = EspDecoratorUtil.getCustomData(model, GetEspReactRenderModelConsts.CustomDataKey);
|
|
39
|
+
if (metadata) {
|
|
40
|
+
return model[metadata.functionName]();
|
|
41
|
+
}
|
|
42
|
+
}
|
|
43
|
+
// else see if there is a function with name GetEspReactRenderModelConsts.HandlerFunctionName we can invoke to get a different model to render?
|
|
44
|
+
let renderModelGetter = model[GetEspReactRenderModelConsts.HandlerFunctionName];
|
|
45
|
+
if (renderModelGetter && utils.isFunction(renderModelGetter)) {
|
|
46
|
+
return renderModelGetter.call(model);
|
|
47
|
+
}
|
|
48
|
+
// else return the initial model passed in
|
|
49
|
+
return model;
|
|
50
|
+
};
|