esp-js-react 8.0.2-next.0 → 8.0.3-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 (36) hide show
  1. package/.dist/esp-react.js +41 -77
  2. package/.dist/esp-react.js.map +1 -1
  3. package/.dist/esp-react.min.js +1 -1
  4. package/.dist/esp-react.min.js.map +1 -1
  5. package/.dist/typings/connect.d.ts +2 -6
  6. package/.dist/typings/connectableComponent.d.ts +0 -16
  7. package/.dist/typings/espModelContextProvider.d.ts +24 -7
  8. package/.dist/typings/espRouterContextProvider.d.ts +5 -5
  9. package/.dist/typings/index.d.ts +0 -1
  10. package/.dist/typings/useModelSelector.d.ts +25 -1
  11. package/.dist/typings/viewBinder.d.ts +8 -1
  12. package/.dist/typings/viewBindingDecorator.d.ts +1 -1
  13. package/package.json +4 -4
  14. package/src/connect.tsx +2 -6
  15. package/src/connectableComponent.tsx +0 -17
  16. package/src/espModelContextProvider.tsx +26 -9
  17. package/src/espRouterContextProvider.tsx +5 -5
  18. package/src/index.ts +0 -4
  19. package/src/useModelSelector.ts +29 -5
  20. package/src/viewBinder.tsx +13 -2
  21. package/src/viewBindingDecorator.ts +2 -2
  22. package/tests/connectableComponentTests.tsx +323 -246
  23. package/tests/espModelContextProviderTests.tsx +142 -0
  24. package/tests/espRouterContextProviderTests.tsx +54 -0
  25. package/tests/indexTests.ts +1 -2
  26. package/tests/testApi/asserts.ts +17 -2
  27. package/tests/testApi/testApi.tsx +37 -21
  28. package/tests/testApi/testModel.ts +15 -8
  29. package/tests/testApi/useStoreReceivedProps.ts +3 -0
  30. package/tests/testApi/viewFactory.tsx +31 -0
  31. package/tests/useModelSelectorTests.tsx +6 -8
  32. package/tests/viewBinderTests.tsx +61 -0
  33. package/.dist/typings/viewBinderConnectable.d.ts +0 -15
  34. package/src/viewBinderConnectable.tsx +0 -54
  35. package/tests/connectableComponentLegacyTests.tsx +0 -405
  36. package/tests/testApi/viewMetadata.tsx +0 -46
@@ -0,0 +1,142 @@
1
+ import {
2
+ EspRouterContextProvider,
3
+ EspModelContextProvider,
4
+ useGetModelId,
5
+ useGetModel,
6
+ usePublishModelEvent,
7
+ usePublishModelEventWithEntityKey
8
+ } from '../src';
9
+ import {testApi, TestApi} from './testApi/testApi';
10
+ import {renderHook} from '@testing-library/react';
11
+ import * as React from 'react';
12
+ import {Router} from 'esp-js';
13
+ import {TestModel} from './testApi/testModel';
14
+
15
+ describe('EspModelContextProviderTests tests', () => {
16
+ let api: TestApi,
17
+ testModel1: TestModel,
18
+ testModel2: TestModel;
19
+
20
+ beforeEach(() => {
21
+ api = testApi();
22
+
23
+ testModel1 = api.setupTestModel('model-id1');
24
+ testModel2 = api.setupTestModel('model-id2');
25
+ });
26
+
27
+ // https://testing-library.com/docs/react-testing-library/api/#renderhook-options-initialprops
28
+ const createEspRouterContextProviderWrapper = (
29
+ router: Router,
30
+ modelsForContextPerRender: TestModel[],
31
+ modelIdForContextPerRender: string[]
32
+ ) => {
33
+
34
+ return ({children}: React.PropsWithChildren) => {
35
+ // Each re-render we pop a model ID out of modelIdForContextPerRender for our context.
36
+ // This is the only way to inject some re-render differences using RTL with renderHook
37
+ let modelForContext = modelsForContextPerRender.length === 1
38
+ ? modelsForContextPerRender[0]
39
+ : modelsForContextPerRender.shift();
40
+ let modelIdForContext = modelIdForContextPerRender.length === 1
41
+ ? modelIdForContextPerRender[0]
42
+ : modelIdForContextPerRender.shift();
43
+ return (
44
+ <EspRouterContextProvider router={router}>
45
+ <EspModelContextProvider modelId={modelIdForContext} model={modelForContext}>
46
+ {children},
47
+ </EspModelContextProvider>
48
+ </EspRouterContextProvider>
49
+ );
50
+ };
51
+ };
52
+
53
+ it('useGetModelId returns new modelId and changes on re-render', () => {
54
+ const {result, rerender} = renderHook(
55
+ props => {
56
+ return useGetModelId();
57
+ },
58
+ {
59
+ wrapper: createEspRouterContextProviderWrapper(
60
+ api.router,
61
+ [testModel1, testModel2],
62
+ ['model-id1', 'model-id2']
63
+ ),
64
+ }
65
+ );
66
+ expect(result.current).toBe('model-id1');
67
+ rerender();
68
+ expect(result.current).toBe('model-id2');
69
+ });
70
+
71
+ it('useGetModel returns model and changes on re-render', () => {
72
+ const {result, rerender} = renderHook(
73
+ props => {
74
+ return useGetModel<TestModel>();
75
+ },
76
+ {
77
+ wrapper: createEspRouterContextProviderWrapper(
78
+ api.router,
79
+ [testModel1, testModel2],
80
+ ['model-id1', 'model-id2']
81
+ ),
82
+ }
83
+ );
84
+ expect(result.current).toBe(testModel1);
85
+ rerender();
86
+ expect(result.current).toBe(testModel2);
87
+ });
88
+
89
+ it('publishModelEvent publishes to correct model and changes on re-render', () => {
90
+ const {result, rerender} = renderHook(
91
+ props => {
92
+ return usePublishModelEvent();
93
+ },
94
+ {
95
+ wrapper: createEspRouterContextProviderWrapper(
96
+ api.router,
97
+ [testModel1, testModel2],
98
+ ['model-id1', 'model-id2']
99
+ ),
100
+ }
101
+ );
102
+
103
+ expect(testModel1.state.value).toBe('initial-value');
104
+ result.current('test-event', 'updated');
105
+ expect(testModel1.state.value).toBe('updated');
106
+
107
+ rerender();
108
+
109
+ expect(testModel2.state.value).toBe('initial-value');
110
+ result.current('test-event', 'updated');
111
+ expect(testModel2.state.value).toBe('updated');
112
+ });
113
+
114
+ it('publishModelEventWithEntityKey publishes to correct model and changes on re-render', () => {
115
+ const {result, rerender} = renderHook(
116
+ props => {
117
+ return usePublishModelEventWithEntityKey();
118
+ },
119
+ {
120
+ wrapper: createEspRouterContextProviderWrapper(
121
+ api.router,
122
+ [testModel1, testModel2],
123
+ ['model-id1', 'model-id2']
124
+ ),
125
+ }
126
+ );
127
+
128
+ expect(testModel1.state.value).toBe('initial-value');
129
+ expect(testModel1.state.entityKey).toBe('');
130
+ result.current('the-entity-key', 'test-event-with-entity-key', 'updated');
131
+ expect(testModel1.state.value).toBe('updated');
132
+ expect(testModel1.state.entityKey).toBe('the-entity-key');
133
+
134
+ rerender();
135
+
136
+ expect(testModel2.state.value).toBe('initial-value');
137
+ expect(testModel2.state.entityKey).toBe('');
138
+ result.current('the-entity-key', 'test-event-with-entity-key', 'updated');
139
+ expect(testModel2.state.value).toBe('updated');
140
+ expect(testModel2.state.entityKey).toBe('the-entity-key');
141
+ });
142
+ });
@@ -0,0 +1,54 @@
1
+ import {
2
+ EspRouterContextProvider,
3
+ useRouter,
4
+ usePublishEvent
5
+ } from '../src';
6
+ import {testApi, TestApi} from './testApi/testApi';
7
+ import {renderHook} from '@testing-library/react';
8
+ import {TestModel} from './testApi/testModel';
9
+ import * as React from 'react';
10
+ import {Router} from 'esp-js';
11
+
12
+ describe('EspRouterContextProvider tests', () => {
13
+ let api: TestApi;
14
+
15
+ beforeEach(() => {
16
+ api = testApi();
17
+
18
+ api.setupTestModel('model-id');
19
+ });
20
+
21
+ // https://testing-library.com/docs/react-testing-library/api/#renderhook-options-initialprops
22
+ const createEspRouterContextProviderWrapper = (router: Router) => {
23
+ return ({ children }: React.PropsWithChildren) => {
24
+ return (<EspRouterContextProvider router={router}>{children}</EspRouterContextProvider>);
25
+ };
26
+ };
27
+
28
+ it('useRouter returns Router', () => {
29
+ const {result} =renderHook(
30
+ props => {
31
+ return useRouter();
32
+ },
33
+ {
34
+ wrapper: createEspRouterContextProviderWrapper(api.router),
35
+ }
36
+ );
37
+ expect(result.current).toBe(api.router);
38
+ });
39
+
40
+ it('usePublishEvent returns publishEvent delegate', () => {
41
+ const {result} =renderHook(
42
+ props => {
43
+ return usePublishEvent();
44
+ },
45
+ {
46
+ wrapper: createEspRouterContextProviderWrapper(api.router),
47
+ }
48
+ );
49
+ let testModel = api.router.getModel<TestModel>('model-id');
50
+ expect(testModel.state.value).toBe('initial-value');
51
+ result.current('model-id', 'test-event', 'updated');
52
+ expect(testModel.state.value).toBe('updated');
53
+ });
54
+ });
@@ -20,9 +20,8 @@ import * as espReact from '../src/index';
20
20
 
21
21
  describe('index exports', () => {
22
22
  it('check exports', () => {
23
- expect(espReact.ViewBinder).toBeDefined();
24
- expect(espReact.ViewBinderConnectable).toBeDefined();
25
23
  expect(espReact.viewBinding).toBeDefined();
24
+ expect(espReact.ViewBinder).toBeDefined();
26
25
  expect(espReact.DEFAULT_VIEW_KEY).toBeDefined();
27
26
  expect(espReact.GetEspPolimerImmutableModelConsts).toBeDefined();
28
27
  expect(espReact.getEspPolimerImmutableModel).toBeDefined();
@@ -8,6 +8,7 @@ export type ViewAsserts = {
8
8
  valueIs(expected: string): ViewAsserts;
9
9
  modelIdIs(expected: string): ViewAsserts
10
10
  propIs(propName: string, expected: string): ViewAsserts
11
+ viewNameElementTextIs(viewName: string);
11
12
  htmlElementInnerTextIs(elementsTestId: string, expectedText: string): ViewAsserts
12
13
  };
13
14
 
@@ -33,6 +34,11 @@ export const viewAsserts = (renderResult: RenderResult) => {
33
34
  expect(span.getAttribute(attributeName)).toBe(expected);
34
35
  return this;
35
36
  },
37
+ viewNameElementTextIs(viewName: string) {
38
+ let span = renderResult.getByTestId('view-name');
39
+ expect(span).toHaveTextContent(viewName);
40
+ return this;
41
+ },
36
42
  htmlElementInnerTextIs(elementsTestId: string, expectedText: string) {
37
43
  let span = renderResult.getByTestId(elementsTestId);
38
44
  expect(span).toHaveTextContent(expectedText);
@@ -49,7 +55,12 @@ export type RouterAsserts = {
49
55
  export const routerAsserts = (routerSpy: RouterSpy) => {
50
56
  return {
51
57
  subscriberCountIs(modelId: string, expectedCount: number) {
52
- expect(routerSpy.getSubscriberCount(modelId)).toEqual(expectedCount);
58
+ if (expectedCount === 0) {
59
+ let modelNotSubscribed = routerSpy.getSubscriberCount(modelId) === undefined || routerSpy.getSubscriberCount(modelId) === 0;
60
+ expect(modelNotSubscribed).toBeTruthy();
61
+ } else {
62
+ expect(routerSpy.getSubscriberCount(modelId)).toEqual(expectedCount);
63
+ }
53
64
  return this;
54
65
  },
55
66
  } as RouterAsserts;
@@ -58,6 +69,7 @@ export const routerAsserts = (routerSpy: RouterSpy) => {
58
69
  export type PropAsserts = {
59
70
  receivedPropCountIs(expectedCount: number): PropAsserts;
60
71
  propAtIndex(index: number, asserter: (props) => void): PropAsserts
72
+ propAtIndexHasModelId(index: number, expectedModelId: string): PropAsserts
61
73
  };
62
74
 
63
75
  export const propAsserts = (testPropStore: TestPropStore) => {
@@ -70,6 +82,9 @@ export const propAsserts = (testPropStore: TestPropStore) => {
70
82
  asserter(testPropStore.receivedProps[index]);
71
83
  return this;
72
84
  },
73
-
85
+ propAtIndexHasModelId(index: number, expectedModelId: string): PropAsserts {
86
+ expect(testPropStore.receivedProps[index].modelId).toBe(expectedModelId);
87
+ return this;
88
+ },
74
89
  } as PropAsserts;
75
90
  };
@@ -4,22 +4,24 @@ import {render, RenderResult} from '@testing-library/react';
4
4
  import * as React from 'react';
5
5
  import {EspModelContextProvider, EspRouterContextProvider} from '../../src';
6
6
  import {PropAsserts, propAsserts, RouterAsserts, routerAsserts, ViewAsserts, viewAsserts} from './asserts';
7
- import {isValidElement} from 'react';
7
+ import {isValidElement, ReactElement} from 'react';
8
8
  import {TestPropStore, TestPropStoreContext} from './useStoreReceivedProps';
9
9
 
10
10
  export type TestApi = {
11
11
  router: RouterSpy;
12
+ propStore: TestPropStore;
12
13
  asserts: {
13
14
  router: RouterAsserts,
14
15
  view: ViewAsserts,
15
16
  props: PropAsserts,
16
17
  };
17
- setupModel(modelId: string, alternativeModel?: object): any;
18
- setupModelAndRender(modelId: string, Component: React.ComponentType): any;
19
- doRender(Component: React.ComponentType, modelIdForContext: string): any
20
- doRender(Component: React.JSX.Element, modelIdForContext: string): any
21
- doReRender(Component: React.ComponentType, modelIdForContext: string): any;
22
- doReRender(Component: React.JSX.Element, modelIdForContext: string): any;
18
+ setupModel<TModel>(modelId: string, model: TModel): TModel;
19
+ setupTestModel(modelId: string): TestModel;
20
+ setupModelAndRender(modelId: string, Component: React.ComponentType): TestApi;
21
+ doRender(Component: React.ComponentType, modelIdForContext?: string): TestApi
22
+ doRender(Component: React.JSX.Element, modelIdForContext?: string): TestApi
23
+ doReRender(Component: React.ComponentType, modelIdForContext?: string, nextProps?: any): TestApi;
24
+ doReRender(Component: React.JSX.Element, modelIdForContext?: string, nextProps?: any): TestApi;
23
25
  };
24
26
 
25
27
  export const testApi = ()=> {
@@ -28,6 +30,7 @@ export const testApi = ()=> {
28
30
  let propStore = new TestPropStore();
29
31
  return {
30
32
  router,
33
+ propStore,
31
34
  asserts: {
32
35
  get router() {
33
36
  return routerAsserts(router);
@@ -40,40 +43,53 @@ export const testApi = ()=> {
40
43
  }
41
44
  },
42
45
  setupModelAndRender(modelId: string, view: React.ComponentType) {
43
- this.setupModel(modelId);
46
+ this.setupTestModel(modelId);
44
47
  this.doRender(view, modelId);
45
48
  return this;
46
49
  },
47
- setupModel(modelId: string, alternativeModel?: object) {
48
- const testModel = alternativeModel || new TestModel(modelId);
50
+ setupModel<TModel>(modelId: string, model: TModel): TModel {
51
+ router.addModel(modelId, model);
52
+ router.observeEventsOn(modelId, model);
53
+ return model;
54
+ },
55
+ setupTestModel(modelId: string): TestModel {
56
+ const testModel = new TestModel(modelId);
49
57
  router.addModel(modelId, testModel);
50
58
  router.observeEventsOn(modelId, testModel);
51
- return this;
59
+ return testModel;
52
60
  },
53
- doRender(ComponentOrElement: any, modelIdForContext: string) {
54
- let e: any = isValidElement(ComponentOrElement)
55
- ? ComponentOrElement
56
- : (<ComponentOrElement />);
61
+ doRender(ComponentOrElement: any, modelIdForContext?: string, nextProps?: any) {
62
+ let element: React.JSX.Element;
63
+ if (isValidElement(ComponentOrElement)) {
64
+ element = ComponentOrElement;
65
+ } else {
66
+ element = <ComponentOrElement />;
67
+ }
68
+ let elementWithProps = React.cloneElement(element, nextProps);
57
69
  renderResult = render((
58
70
  <TestPropStoreContext.Provider value={propStore}>
59
71
  <EspRouterContextProvider router={router}>
60
72
  <EspModelContextProvider modelId={modelIdForContext}>
61
- {e},
73
+ {elementWithProps},
62
74
  </EspModelContextProvider>
63
75
  </EspRouterContextProvider>
64
76
  </TestPropStoreContext.Provider>
65
77
  ));
66
78
  return this;
67
79
  },
68
- doReRender(ComponentOrElement: any, modelIdForContext: string) {
69
- let componentOrElement: any = isValidElement(ComponentOrElement)
70
- ? ComponentOrElement
71
- : (<ComponentOrElement />);
80
+ doReRender(ComponentOrElement: any, modelIdForContext?: string, nextProps?: any) {
81
+ let element: React.JSX.Element;
82
+ if (isValidElement(ComponentOrElement)) {
83
+ element = ComponentOrElement;
84
+ } else {
85
+ element = <ComponentOrElement />;
86
+ }
87
+ let elementWithProps = React.cloneElement(element, nextProps);
72
88
  renderResult.rerender((
73
89
  <TestPropStoreContext.Provider value={propStore}>
74
90
  <EspRouterContextProvider router={router}>
75
91
  <EspModelContextProvider modelId={modelIdForContext}>
76
- {componentOrElement},
92
+ {elementWithProps},
77
93
  </EspModelContextProvider>
78
94
  </EspRouterContextProvider>
79
95
  </TestPropStoreContext.Provider>
@@ -1,7 +1,7 @@
1
- import {observeEvent} from 'esp-js';
1
+ import {EventContext, observeEvent} from 'esp-js';
2
2
  import {GetEspPolimerImmutableModelConsts} from '../../src';
3
3
 
4
- export type TestModelImmutableState = { value: string, modelId: string };
4
+ export type TestModelImmutableState = { value: string, modelId: string, entityKey: string };
5
5
 
6
6
  export class TestModel {
7
7
 
@@ -10,16 +10,13 @@ export class TestModel {
10
10
  constructor(modelId: string) {
11
11
  this._internalState = {
12
12
  value: 'initial-value',
13
+ entityKey: '',
13
14
  modelId: modelId,
14
15
  };
15
16
  }
16
17
 
17
- public get valueViaModelGetter() {
18
- return this._internalState.value;
19
- }
20
-
21
- public get modelIdViaModelGetter() {
22
- return this._internalState.modelId;
18
+ public get state(): TestModelImmutableState {
19
+ return this._internalState;
23
20
  }
24
21
 
25
22
  @observeEvent('test-event')
@@ -31,6 +28,16 @@ export class TestModel {
31
28
  };
32
29
  }
33
30
 
31
+ @observeEvent('test-event-with-entity-key')
32
+ _onTestEventWithEntityKey(ev: string, eventContext: EventContext) {
33
+ // mimic some immutable logic that would be provided by a lib such as immer in a real app.
34
+ this._internalState = {
35
+ ...this._internalState,
36
+ entityKey: eventContext.entityKey,
37
+ value: ev
38
+ };
39
+ }
40
+
34
41
  [GetEspPolimerImmutableModelConsts.HandlerFunctionName]: () => TestModelImmutableState = () => {
35
42
  return this._internalState;
36
43
  };
@@ -8,4 +8,7 @@ export class TestPropStore {
8
8
  pushProps(props: any) {
9
9
  this.receivedProps.push(props);
10
10
  }
11
+ getLastProps(): any {
12
+ return this.receivedProps[this.receivedProps.length -1];
13
+ }
11
14
  }
@@ -0,0 +1,31 @@
1
+ import {useTestPropStore} from './useStoreReceivedProps';
2
+ import * as React from 'react';
3
+
4
+ export const viewFactory = (name: string) => {
5
+ return (props: { modelId: string; value: string, [key: string]: any }) => {
6
+ let testPropStore = useTestPropStore();
7
+ testPropStore.pushProps(props);
8
+ return (
9
+ <>
10
+ <span data-testid='view-name'>{name}</span>
11
+ <ViewMetadata modelId={props.modelId} modelValue={props.value} {...props}/>
12
+ </>
13
+ );
14
+ };
15
+ };
16
+
17
+ export type ViewMetadataProps = {
18
+ modelId: string,
19
+ modelValue: string
20
+ [key: string]: string; // ...rest props
21
+ };
22
+
23
+ export const ViewMetadata = (props: ViewMetadataProps) => {
24
+ const { modelId, modelValue, ...rest} = props;
25
+ return (
26
+ <div>
27
+ <span data-testid='modelIdDisplay'>{modelId}</span>
28
+ <span data-testid='valueDisplay'>{modelValue}</span>
29
+ </div>
30
+ );
31
+ };
@@ -3,7 +3,7 @@ import * as React from 'react';
3
3
  import {act} from 'react';
4
4
  import {modelSelectorOptions, useModelSelector} from '../src';
5
5
  import {TestModel, TestModelImmutableState} from './testApi/testModel';
6
- import {ViewMetadata} from './testApi/viewMetadata';
6
+ import {ViewMetadata} from './testApi/viewFactory';
7
7
  import {routerAsserts} from './testApi/asserts';
8
8
  import {testApi, TestApi} from './testApi/testApi';
9
9
 
@@ -70,7 +70,7 @@ describe('useModelSelector', () => {
70
70
  };
71
71
 
72
72
  beforeEach(() => {
73
- api.setupModel(modelId);
73
+ api.setupTestModel(modelId);
74
74
  api.doRender(View, undefined);
75
75
  });
76
76
 
@@ -152,7 +152,7 @@ describe('useModelSelector', () => {
152
152
  };
153
153
 
154
154
  beforeEach(() => {
155
- api.setupModel(modelId1);
155
+ api.setupTestModel(modelId1);
156
156
  api.doRender(View, modelId1);
157
157
  });
158
158
 
@@ -173,7 +173,7 @@ describe('useModelSelector', () => {
173
173
  api.asserts.view
174
174
  .modelIdIs('')
175
175
  .valueIs('');
176
- api.setupModel(modelId2);
176
+ api.setupTestModel(modelId2);
177
177
  api.doReRender(View, modelId2);
178
178
  api.asserts.view
179
179
  .modelIdIs(modelId2)
@@ -194,7 +194,7 @@ describe('useModelSelector', () => {
194
194
  const values: string[] = useModelSelector<TestModel, string[]>(
195
195
  model => {
196
196
  // here we're expecting to receive a TestModel, not testModelInstance[GetEspPolimerImmutableModelConsts.HandlerFunctionName]()
197
- return [model.modelIdViaModelGetter, model.valueViaModelGetter];
197
+ return [model.state.modelId, model.state.value];
198
198
  },
199
199
  modelSelectorOptions().setTryPreSelectPolimerImmutableModel(false)
200
200
  );
@@ -211,8 +211,6 @@ describe('useModelSelector', () => {
211
211
  });
212
212
 
213
213
  it('selector passes router root model to selector', () => {
214
- // Not much to test here, it's really in the View logic for this case.
215
- // If the below passes, it means the selector was given the root ESP model.
216
214
  api.asserts.view
217
215
  .modelIdIs(modelId)
218
216
  .valueIs('initial-value');
@@ -231,7 +229,7 @@ describe('useModelSelector', () => {
231
229
  return;
232
230
  }
233
231
  return (
234
- <ViewMetadata modelId={model.modelIdViaModelGetter} modelValue={model.valueViaModelGetter} />
232
+ <ViewMetadata modelId={model.state.modelId} modelValue={model.state.value} />
235
233
  );
236
234
  };
237
235
 
@@ -0,0 +1,61 @@
1
+ import {
2
+ viewBinding,
3
+ ViewBinder, ViewBinderConnectable
4
+ } from '../src';
5
+ import {testApi, TestApi} from './testApi/testApi';
6
+ import * as React from 'react';
7
+ import {viewFactory} from './testApi/viewFactory';
8
+
9
+ @viewBinding(viewFactory('ViewBinder1'))
10
+ @viewBinding(viewFactory('ViewBinder2'), 'alternative-view-context')
11
+ class TestModel {
12
+ public value: string;
13
+
14
+ constructor() {
15
+ this.value = 'initial-value';
16
+ }
17
+ }
18
+
19
+ describe('ViewBinder tests', () => {
20
+ let api: TestApi,
21
+ testModel1: TestModel;
22
+
23
+ beforeEach(() => {
24
+ api = testApi();
25
+ testModel1 = new TestModel();
26
+ api.setupModel('model-id', testModel1);
27
+ });
28
+
29
+ it('creates view using the view found on decorator', () => {
30
+ api.doRender(
31
+ (
32
+ <ViewBinder model={testModel1} />
33
+ ),
34
+ 'model-id'
35
+ );
36
+ api.asserts.view.viewNameElementTextIs('ViewBinder1');
37
+ });
38
+
39
+ it('creates view using the view found on decorator with specific context', () => {
40
+ api.doRender(
41
+ (
42
+ <ViewBinder model={testModel1} viewContext={'alternative-view-context'} />
43
+ ),
44
+ 'model-id'
45
+ );
46
+ api.asserts.view.viewNameElementTextIs('ViewBinder2');
47
+ });
48
+
49
+ it('arbitrary props are passed down to the child', () => {
50
+ api.doRender(
51
+ (
52
+ <ViewBinder model={testModel1} className={'foo-bar'} />
53
+ ),
54
+ 'model-id1'
55
+ );
56
+ api.asserts.props
57
+ .propAtIndex(0, props => {
58
+ expect(props.className).toBe('foo-bar');
59
+ });
60
+ });
61
+ });
@@ -1,15 +0,0 @@
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,54 +0,0 @@
1
- import {useRouter} from './espRouterContextProvider';
2
- import {EspModelContextProvider} from './espModelContextProvider';
3
- import {Logger, Router} from 'esp-js';
4
- import * as React from 'react';
5
- import {modelSelectorOptions, useModelSelector} from './useModelSelector';
6
- import {createViewForModel} from './viewBindingDecorator';
7
- import {tryGetPolimerImmutableModel} from './polimer/getEspPolimerImmutableModel';
8
-
9
- const _log = Logger.create('ViewBinderConnectable');
10
-
11
- export interface ViewBinderConnectableProps {
12
- modelId?: string;
13
- viewContext?: string;
14
- view?: React.ComponentType;
15
- }
16
-
17
- interface ViewBinderConnectableChildProps {
18
- modelId: string;
19
- model: object;
20
- router: Router;
21
- }
22
-
23
- /**
24
- * Dynamically binds a view found via @viewBinder(SomeJsXView) to a model managed by the Router.
25
- * Optionally provide a view override and/or a viewContext
26
- * @param modelId
27
- * @param viewContext
28
- * @param view
29
- * @constructor
30
- */
31
- export const ViewBinderConnectable = ({modelId, viewContext, view}: ViewBinderConnectableProps) => {
32
- const router = useRouter();
33
- const model = useModelSelector<object, object>(
34
- m => m,
35
- modelSelectorOptions()
36
- .setModelId(modelId)
37
- .setTryPreSelectPolimerImmutableModel(false)
38
- );
39
- if (!model) {
40
- return null;
41
- }
42
- let immutableModel = tryGetPolimerImmutableModel<object>(model);
43
- const childProps: ViewBinderConnectableChildProps = {
44
- modelId,
45
- router: router,
46
- model: immutableModel
47
- };
48
- let viewElement = createViewForModel(model, childProps, viewContext, view);
49
- return (
50
- <EspModelContextProvider modelId={modelId} router={router} model={immutableModel} {...childProps}>
51
- {viewElement}
52
- </EspModelContextProvider>
53
- );
54
- };