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.
Files changed (41) hide show
  1. package/.dist/esp-react.js +425 -510
  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 +7 -8
  9. package/.dist/typings/espRouterContext.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 +13 -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 +93 -190
  19. package/src/espModelContext.tsx +49 -23
  20. package/src/espRouterContext.tsx +88 -0
  21. package/src/index.ts +32 -16
  22. package/src/polimer/getEspReactRenderModel.ts +50 -0
  23. package/src/useModelSelector.ts +94 -0
  24. package/src/viewBinder.tsx +14 -22
  25. package/src/viewBinderConnectable.tsx +53 -0
  26. package/src/viewBindingDecorator.ts +2 -3
  27. package/tests/connectWithSelectorTests.tsx +67 -0
  28. package/tests/connectableComponentLegacyTests.tsx +405 -0
  29. package/tests/indexTests.ts +0 -12
  30. package/.dist/typings/routerProvider.d.ts +0 -18
  31. package/.dist/typings/shallowEqual.d.ts +0 -21
  32. package/.dist/typings/shouldUpdateMixin.d.ts +0 -10
  33. package/.dist/typings/smartComponent.d.ts +0 -33
  34. package/.dist/typings/utils.d.ts +0 -5
  35. package/src/getEspReactRenderModel.ts +0 -27
  36. package/src/routerProvider.tsx +0 -47
  37. package/src/shallowEqual.ts +0 -70
  38. package/src/shouldUpdateMixin.ts +0 -73
  39. package/src/smartComponent.tsx +0 -93
  40. package/src/utils.ts +0 -61
  41. 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
- export type PublishEvent = (eventType: string, event: any) => void;
5
- export type CreatePublishEventProps<TPublishEventProps> = (publishEvent: PublishEvent) => TPublishEventProps;
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
- export type ViewComponentTypes = React.FunctionComponent | React.ClassType<any, any, any> | React.ComponentClass;
11
+ /**
12
+ * @deprecated
13
+ */
8
14
  export interface ConnectableComponentProps<TModel = {}, TPublishEventProps = {}, TModelMappedToProps = {}> {
9
15
  modelId?: string;
10
16
  viewContext?: string;
11
- view?: ViewComponentTypes;
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
- export interface ConnectableComponentChildProps<TModel> {
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
- export interface State {
26
- model?: any;
27
- currentModelId?: string;
28
- publishProps?: any;
29
- publishEvent?: PublishModelEventDelegate;
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: () => GetModelIdDelegate;
10
- export type PublishEventDelegate = (modelIdOrModelAddress: string | ModelAddress, eventType: string, event: any) => void;
11
- export declare const PublishEventContext: React.Context<PublishEventDelegate>;
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 can be used to publish an event.
12
+ * Returns a function which will return the model set at last dispatch.
14
13
  */
15
- export declare const usePublishEvent: () => PublishEventDelegate;
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
- router: Router;
33
+ model?: unknown;
35
34
  }
36
- export declare const EspModelContext: ({ modelId, children, router }: PropsWithChildren<EspModelContextProps>) => React.JSX.Element;
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;
@@ -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 * from './getEspReactRenderModel';
7
- export { shouldUpdateMixin } from './shouldUpdateMixin';
5
+ export { GetEspReactRenderModelMetadata, GetEspReactRenderModelConsts, getEspReactRenderModel } from './polimer/getEspReactRenderModel';
8
6
  export { createViewForModel } from './viewBindingDecorator';
9
- export { ConnectableComponent, connect, ConnectableComponentProps, MapModelToProps, CreatePublishEventProps, ConnectableView, ConnectableComponentChildProps, } from './connectableComponent';
10
- export { useGetModelId, GetModelIdDelegate, GetModelIdContext, PublishEventDelegate, PublishEventContext, usePublishEvent, PublishModelEventDelegate, PublishModelEventContext, usePublishModelEvent, PublishModelEventWithEntityKeyDelegate, PublishModelEventWithEntityKeyContext, usePublishModelEventWithEntityKey, EspModelContext, EspModelContextProps } from './espModelContext';
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 class ViewBinder extends React.Component<ViewBinderProps> {
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: ViewComponentTypes): React.CElement<any, React.Component<any, any, any>>;
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": "7.0.2-next.0",
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": "^7.0.2-next.0",
28
- "esp-js-polimer": "^7.0.2-next.0",
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": "^16.14.0"
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": "^16.0.0"
44
+ "react": "^18.0.0"
44
45
  },
45
- "gitHead": "aa12a7fe22358df3d317dd9f4a2f41c179a3c071"
46
+ "gitHead": "323e76ba03a81860fb027d319eb16b26a1c3e6df"
46
47
  }
@@ -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 * 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 './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
- 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
+ modelId,
102
+ false
103
+ );
104
+ if (model == null) {
105
+ return null;
188
106
  }
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
- };
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
  };