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.
Files changed (43) hide show
  1. package/.dist/esp-react.js +468 -511
  2. package/.dist/esp-react.js.map +1 -1
  3. package/.dist/esp-react.min.js +2 -1
  4. package/.dist/esp-react.min.js.LICENSE.txt +9 -0
  5. package/.dist/esp-react.min.js.map +1 -1
  6. package/.dist/typings/connect.d.ts +12 -0
  7. package/.dist/typings/connectableComponent.d.ts +20 -46
  8. package/.dist/typings/{espModelContext.d.ts → espModelContextProvider.d.ts} +8 -9
  9. package/.dist/typings/espRouterContextProvider.d.ts +47 -0
  10. package/.dist/typings/index.d.ts +7 -6
  11. package/.dist/typings/{getEspReactRenderModel.d.ts → polimer/getEspReactRenderModel.d.ts} +7 -0
  12. package/.dist/typings/useModelSelector.d.ts +27 -0
  13. package/.dist/typings/viewBinder.d.ts +1 -8
  14. package/.dist/typings/viewBinderConnectable.d.ts +15 -0
  15. package/.dist/typings/viewBindingDecorator.d.ts +1 -2
  16. package/package.json +7 -6
  17. package/src/connect.tsx +31 -0
  18. package/src/connectableComponent.tsx +94 -190
  19. package/src/espModelContextProvider.tsx +95 -0
  20. package/src/espRouterContextProvider.tsx +88 -0
  21. package/src/index.ts +40 -18
  22. package/src/polimer/getEspReactRenderModel.ts +50 -0
  23. package/src/useModelSelector.ts +159 -0
  24. package/src/viewBinder.tsx +14 -22
  25. package/src/viewBinderConnectable.tsx +54 -0
  26. package/src/viewBindingDecorator.ts +2 -3
  27. package/tests/connectableComponentLegacyTests.tsx +405 -0
  28. package/tests/indexTests.ts +0 -12
  29. package/tests/routerSpy.ts +24 -0
  30. package/tests/useModelSelectorTests.tsx +361 -0
  31. package/.dist/typings/routerProvider.d.ts +0 -18
  32. package/.dist/typings/shallowEqual.d.ts +0 -21
  33. package/.dist/typings/shouldUpdateMixin.d.ts +0 -10
  34. package/.dist/typings/smartComponent.d.ts +0 -33
  35. package/.dist/typings/utils.d.ts +0 -5
  36. package/src/espModelContext.tsx +0 -69
  37. package/src/getEspReactRenderModel.ts +0 -27
  38. package/src/routerProvider.tsx +0 -47
  39. package/src/shallowEqual.ts +0 -70
  40. package/src/shouldUpdateMixin.ts +0 -73
  41. package/src/smartComponent.tsx +0 -93
  42. package/src/utils.ts +0 -61
  43. package/tests/connectableComponentTests.tsx +0 -390
@@ -1,211 +1,115 @@
1
1
  import * as React from 'react';
2
- import * as PropTypes from 'prop-types';
3
- import {Disposable, Router, EspDecoratorUtil, utils, DisposableBase} from 'esp-js';
4
- import {createViewForModel } from './viewBindingDecorator';
5
- import {GetEspReactRenderModelConsts, GetEspReactRenderModelMetadata} from './getEspReactRenderModel';
6
- import {EspModelContext} from './espModelContext';
7
-
8
- export type PublishEvent = (eventType: string, event: any) => void;
9
-
10
- export type CreatePublishEventProps<TPublishEventProps> = (publishEvent: PublishEvent) => TPublishEventProps;
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
- export type ViewComponentTypes = React.FunctionComponent | React.ClassType<any, any, any> | React.ComponentClass;
15
-
16
- export interface ConnectableComponentProps<TModel ={}, TPublishEventProps = {}, TModelMappedToProps = {}> {
20
+ /**
21
+ * @deprecated
22
+ */
23
+ export interface ConnectableComponentProps<TModel = {}, TPublishEventProps = {}, TModelMappedToProps = {}> {
17
24
  modelId?: string;
18
25
  viewContext?: string;
19
- view?: ViewComponentTypes;
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
- export interface ConnectableComponentChildProps<TModel> {
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, including the result of mapPublish and mapPublish if 'connect' was used
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
- export type PublishModelEventDelegate = (eventType: string, event: any) => void;
48
-
49
- export class ConnectableComponent<TModel, TPublishEventProps = {}, TModelMappedToProps = {}> extends React.Component<ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>, State> {
50
- private _isMounted = false;
51
- private _observationSubscription: Disposable;
52
- context: ConnectableComponentContext;
53
-
54
- static contextTypes = {
55
- router: PropTypes.instanceOf(Router).isRequired,
56
- modelId: PropTypes.string
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
- constructor(props: ConnectableComponentProps<TModel, TPublishEventProps, TModelMappedToProps>, context: ConnectableComponentContext) {
60
- super(props, context);
61
- this.state = {model: null, currentModelId: null};
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
- * 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
172
- */
173
- private _getRenderModel(model: any): TModel {
174
- // does the given model have a decorated function we can invoke to get a different model to render?
175
- if (EspDecoratorUtil.hasMetadata(model)) {
176
- let metadata: GetEspReactRenderModelMetadata = EspDecoratorUtil.getCustomData(model, GetEspReactRenderModelConsts.CustomDataKey);
177
- if (metadata) {
178
- return model[metadata.functionName]();
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
- // else see if there is a function with name GetEspReactRenderModelConsts.HandlerFunctionName we can invoke to get a different model to render?
182
- let renderModelGetter = model[GetEspReactRenderModelConsts.HandlerFunctionName];
183
- if (renderModelGetter && utils.isFunction(renderModelGetter)) {
184
- return renderModelGetter.call(model);
185
- }
186
- // else just return the default model
187
- return model;
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
- // Lifting 'ConnectableView' into it's own type so it can be exported, else tsc doesn't correctly generated declaration files
192
- export type ConnectableView = React.ComponentClass | React.SFC;
193
-
194
- export const connect = function<TModel, TPublishEventProps, TModelMappedToProps = {}>(
195
- mapModelToProps?: MapModelToProps<TModel, TModelMappedToProps, TPublishEventProps>,
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 * from './getEspReactRenderModel';
28
- export {shouldUpdateMixin} from './shouldUpdateMixin';
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
- ConnectableComponentProps,
34
- MapModelToProps,
37
+ ConnectableComponentFactory
38
+ } from './connect';
39
+ export {
35
40
  CreatePublishEventProps,
36
- ConnectableView,
41
+ MapModelToProps,
42
+ ConnectableComponentProps,
37
43
  ConnectableComponentChildProps,
44
+ ConnectableComponent,
38
45
  } from './connectableComponent';
39
46
  export {
40
- useGetModelId,
41
- GetModelIdDelegate,
42
- GetModelIdContext,
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
- EspModelContext,
57
- EspModelContextProps
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
+ };