esp-js-react 8.0.1-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 (42) hide show
  1. package/.dist/esp-react.js +68 -104
  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 +2 -3
  10. package/.dist/typings/polimer/getEspPolimerImmutableModel.d.ts +21 -0
  11. package/.dist/typings/useModelSelector.d.ts +25 -1
  12. package/.dist/typings/viewBinder.d.ts +8 -1
  13. package/.dist/typings/viewBindingDecorator.d.ts +1 -1
  14. package/package.json +4 -4
  15. package/src/connect.tsx +2 -6
  16. package/src/connectableComponent.tsx +2 -19
  17. package/src/espModelContextProvider.tsx +26 -9
  18. package/src/espRouterContextProvider.tsx +5 -5
  19. package/src/index.ts +5 -9
  20. package/src/polimer/getEspPolimerImmutableModel.ts +50 -0
  21. package/src/useModelSelector.ts +31 -7
  22. package/src/viewBinder.tsx +13 -2
  23. package/src/viewBindingDecorator.ts +2 -2
  24. package/tests/connectableComponentTests.tsx +496 -0
  25. package/tests/espModelContextProviderTests.tsx +142 -0
  26. package/tests/espRouterContextProviderTests.tsx +54 -0
  27. package/tests/indexTests.ts +24 -91
  28. package/tests/testApi/asserts.ts +90 -0
  29. package/tests/testApi/testApi.tsx +100 -0
  30. package/tests/testApi/testModel.ts +44 -0
  31. package/tests/testApi/useStoreReceivedProps.ts +14 -0
  32. package/tests/testApi/viewFactory.tsx +31 -0
  33. package/tests/useModelSelectorTests.tsx +47 -153
  34. package/tests/viewBinderTests.tsx +61 -0
  35. package/.dist/typings/polimer/getEspReactRenderModel.d.ts +0 -21
  36. package/.dist/typings/viewBinderConnectable.d.ts +0 -15
  37. package/src/polimer/getEspReactRenderModel.ts +0 -50
  38. package/src/viewBinderConnectable.tsx +0 -54
  39. package/tests/connectableComponentLegacyTests.tsx +0 -405
  40. /package/.dist/typings/polimer/{polimerExtentsions.d.ts → polimerModelBuilderExtentsions.d.ts} +0 -0
  41. /package/src/polimer/{polimerExtentsions.ts → polimerModelBuilderExtentsions.ts} +0 -0
  42. /package/tests/{routerSpy.ts → testApi/routerSpy.ts} +0 -0
@@ -1,126 +1,26 @@
1
1
  import 'jest';
2
2
  import * as React from 'react';
3
3
  import {act} from 'react';
4
- import {configure, render, RenderResult} from '@testing-library/react';
5
- import {useModelSelector, EspModelContextProvider, EspRouterContextProvider, GetEspReactRenderModelConsts, modelSelectorOptions} from '../src';
6
- import {observeEvent} from 'esp-js';
7
- // import for extra asserts
8
- import '@testing-library/jest-dom';
9
- import {RouterSpy} from './routerSpy';
10
-
11
- type TestModelImmutableStateState = { value: string, modelId: string };
12
- configure({reactStrictMode: false});
13
-
14
- class TestModel {
15
-
16
- private _internalState: TestModelImmutableStateState;
17
-
18
- constructor(modelId: string) {
19
- this._internalState = {
20
- value: 'initial-value',
21
- modelId: modelId,
22
- };
23
- }
24
-
25
- public get valueViaModelGetter() {
26
- return this._internalState.value;
27
- }
28
-
29
- public get modelIdViaModelGetter() {
30
- return this._internalState.modelId;
31
- }
32
-
33
- @observeEvent('test-event')
34
- _onTestEvent(ev: string) {
35
- // mimic some immutable logic that would be provided by a lib such as immer in a real app.
36
- this._internalState = {
37
- ...this._internalState,
38
- value: ev
39
- };
40
- }
41
-
42
- [GetEspReactRenderModelConsts.HandlerFunctionName]: () => TestModelImmutableStateState = () => {
43
- return this._internalState;
44
- };
45
- }
46
-
47
- const ViewMetadata = ({modelId, modelValue}: {modelId: string, modelValue: string}) => {
48
- return (
49
- <div>
50
- <span data-testid='modelIdDisplay'>{modelId}</span>
51
- <span data-testid='valueDisplay'>{modelValue}</span>
52
- </div>
53
- );
54
- };
55
-
56
- const viewAsserts = (renderResult: RenderResult) => {
57
- let valueElement = renderResult.getByTestId('valueDisplay');
58
- let idElement = renderResult.getByTestId('modelIdDisplay');
59
-
60
- expect(valueElement).toBeInTheDocument();
61
- expect(idElement).toBeInTheDocument();
62
- return {
63
- modelIdIs(expected: string) {
64
- expect(idElement).toHaveTextContent(expected);
65
- return this;
66
- },
67
- valueIs(expected: string) {
68
- expect(valueElement).toHaveTextContent(expected);
69
- return this;
70
- },
71
- };
72
- };
73
-
74
- const routerAsserts = (routerSpy: RouterSpy) => {
75
- return {
76
- subscriberCountIs(modelId: string, expectedCount: number) {
77
- expect(routerSpy.getSubscriberCount(modelId)).toEqual(expectedCount);
78
- return this;
79
- },
80
- };
81
- };
4
+ import {modelSelectorOptions, useModelSelector} from '../src';
5
+ import {TestModel, TestModelImmutableState} from './testApi/testModel';
6
+ import {ViewMetadata} from './testApi/viewFactory';
7
+ import {routerAsserts} from './testApi/asserts';
8
+ import {testApi, TestApi} from './testApi/testApi';
82
9
 
83
10
  type SelectedObject = { id: string, value: string };
84
11
 
85
12
  describe('useModelSelector', () => {
86
- let router: RouterSpy,
87
- renderResult: RenderResult;
13
+ let api: TestApi;
88
14
 
89
15
  beforeEach(() => {
90
- router = new RouterSpy();
16
+ api = testApi();
91
17
  });
92
18
 
93
- function setupModel(modelId: string) {
94
- const testModel = new TestModel(modelId);
95
- router.addModel(modelId, testModel);
96
- router.observeEventsOn(modelId, testModel);
97
- }
98
-
99
- function doRender(Component: React.ComponentType, modelIdForContext: string) {
100
- renderResult = render((
101
- <EspRouterContextProvider router={router}>
102
- <EspModelContextProvider modelId={modelIdForContext}>
103
- <Component/>,
104
- </EspModelContextProvider>
105
- </EspRouterContextProvider>
106
- ));
107
- }
108
-
109
- function doReRender(Component: React.ComponentType, modelIdForContext: string) {
110
- renderResult.rerender((
111
- <EspRouterContextProvider router={router}>
112
- <EspModelContextProvider modelId={modelIdForContext}>
113
- <Component/>,
114
- </EspModelContextProvider>
115
- </EspRouterContextProvider>
116
- ));
117
- }
118
-
119
19
  describe('Default API case', () => {
120
20
  const modelId = 'modelId';
121
21
 
122
22
  const View = () => {
123
- const valuesObj = useModelSelector<TestModelImmutableStateState, SelectedObject>(
23
+ const valuesObj = useModelSelector<TestModelImmutableState, SelectedObject>(
124
24
  model => {
125
25
  return {id: model.modelId, value: model.value};
126
26
  },
@@ -134,21 +34,20 @@ describe('useModelSelector', () => {
134
34
  };
135
35
 
136
36
  beforeEach(() => {
137
- setupModel(modelId);
138
- doRender(View, modelId);
37
+ api.setupModelAndRender(modelId, View);
139
38
  });
140
39
 
141
40
  it('renders immutable model based on modelId found on context', () => {
142
- viewAsserts(renderResult)
41
+ api.asserts.view
143
42
  .modelIdIs(modelId)
144
43
  .valueIs('initial-value');
145
44
  });
146
45
 
147
46
  it('updates are rendered', () => {
148
47
  act(() => {
149
- router.publishEvent(modelId, 'test-event', 'new-value');
48
+ api.router.publishEvent(modelId, 'test-event', 'new-value');
150
49
  });
151
- viewAsserts(renderResult)
50
+ api.asserts.view
152
51
  .modelIdIs(modelId)
153
52
  .valueIs('new-value');
154
53
  });
@@ -158,7 +57,7 @@ describe('useModelSelector', () => {
158
57
  const modelId = 'modelId';
159
58
 
160
59
  const View = () => {
161
- const values: string[] = useModelSelector<TestModelImmutableStateState, string[]>(
60
+ const values: string[] = useModelSelector<TestModelImmutableState, string[]>(
162
61
  model => [model.modelId, model.value],
163
62
  modelSelectorOptions().setModelId(modelId)
164
63
  );
@@ -171,12 +70,12 @@ describe('useModelSelector', () => {
171
70
  };
172
71
 
173
72
  beforeEach(() => {
174
- setupModel(modelId);
175
- doRender(View, undefined);
73
+ api.setupTestModel(modelId);
74
+ api.doRender(View, undefined);
176
75
  });
177
76
 
178
77
  it('renders correct model data', () => {
179
- viewAsserts(renderResult)
78
+ api.asserts.view
180
79
  .modelIdIs(modelId)
181
80
  .valueIs('initial-value');
182
81
  });
@@ -186,7 +85,7 @@ describe('useModelSelector', () => {
186
85
  const modelId = 'modelId';
187
86
 
188
87
  const View = () => {
189
- const values = useModelSelector<TestModelImmutableStateState, SelectedObject>(
88
+ const values = useModelSelector<TestModelImmutableState, SelectedObject>(
190
89
  model => ({id: model.modelId, value: model.value}),
191
90
  modelSelectorOptions<SelectedObject>()
192
91
  .setEqualityFn((a, b) => {
@@ -207,30 +106,29 @@ describe('useModelSelector', () => {
207
106
  };
208
107
 
209
108
  beforeEach(() => {
210
- setupModel(modelId);
211
- doRender(View, modelId);
109
+ api.setupModelAndRender(modelId, View);
212
110
  });
213
111
 
214
112
  it('renders initial model data', () => {
215
- viewAsserts(renderResult)
113
+ api.asserts.view
216
114
  .modelIdIs(modelId)
217
115
  .valueIs('initial-value');
218
116
  });
219
117
 
220
118
  it('updates are ignored due to equalityFn', () => {
221
- viewAsserts(renderResult)
119
+ api.asserts.view
222
120
  .modelIdIs(modelId)
223
121
  .valueIs('initial-value');
224
122
  act(() => {
225
- router.publishEvent(modelId, 'test-event', 'assume-no-change');
123
+ api.router.publishEvent(modelId, 'test-event', 'assume-no-change');
226
124
  });
227
- viewAsserts(renderResult)
125
+ api.asserts.view
228
126
  .modelIdIs(modelId)
229
127
  .valueIs('initial-value'); // event data WAS NOT propagated
230
128
  act(() => {
231
- router.publishEvent(modelId, 'test-event', 'do-change');
129
+ api.router.publishEvent(modelId, 'test-event', 'do-change');
232
130
  });
233
- viewAsserts(renderResult)
131
+ api.asserts.view
234
132
  .modelIdIs(modelId)
235
133
  .valueIs('do-change'); // event data WAS propagated
236
134
  });
@@ -241,7 +139,7 @@ describe('useModelSelector', () => {
241
139
  const modelId2 = 'modelId2';
242
140
 
243
141
  const View = (props: {modelId: string}) => {
244
- const values = useModelSelector<TestModelImmutableStateState, SelectedObject>(
142
+ const values = useModelSelector<TestModelImmutableState, SelectedObject>(
245
143
  model => ({id: model.modelId, value: model.value}),
246
144
  modelSelectorOptions().setModelId(props.modelId)
247
145
  );
@@ -254,36 +152,36 @@ describe('useModelSelector', () => {
254
152
  };
255
153
 
256
154
  beforeEach(() => {
257
- setupModel(modelId1);
258
- doRender(View, modelId1);
155
+ api.setupTestModel(modelId1);
156
+ api.doRender(View, modelId1);
259
157
  });
260
158
 
261
159
  it('selector subscribed to Router', () => {
262
- routerAsserts(router).subscriberCountIs(modelId1, 1);
160
+ routerAsserts(api.router).subscriberCountIs(modelId1, 1);
263
161
  });
264
162
 
265
163
  it('unsubscribes when modelId changes', () => {
266
- doReRender(View, undefined);
267
- routerAsserts(router).subscriberCountIs(modelId1, 0);
164
+ api.doReRender(View, undefined);
165
+ api.asserts.router.subscriberCountIs(modelId1, 0);
268
166
  });
269
167
 
270
168
  it('resubscribes to new model when modelId changes', () => {
271
- viewAsserts(renderResult)
169
+ api.asserts.view
272
170
  .modelIdIs(modelId1)
273
171
  .valueIs('initial-value');
274
- doReRender(View, undefined);
275
- viewAsserts(renderResult)
172
+ api.doReRender(View, undefined);
173
+ api.asserts.view
276
174
  .modelIdIs('')
277
175
  .valueIs('');
278
- setupModel(modelId2);
279
- doReRender(View, modelId2);
280
- viewAsserts(renderResult)
176
+ api.setupTestModel(modelId2);
177
+ api.doReRender(View, modelId2);
178
+ api.asserts.view
281
179
  .modelIdIs(modelId2)
282
180
  .valueIs('initial-value');
283
181
  act(() => {
284
- router.publishEvent(modelId2, 'test-event', 'updated');
182
+ api.router.publishEvent(modelId2, 'test-event', 'updated');
285
183
  });
286
- viewAsserts(renderResult)
184
+ api.asserts.view
287
185
  .modelIdIs(modelId2)
288
186
  .valueIs('updated');
289
187
  });
@@ -295,8 +193,8 @@ describe('useModelSelector', () => {
295
193
  const View = () => {
296
194
  const values: string[] = useModelSelector<TestModel, string[]>(
297
195
  model => {
298
- // here we're expecting to receive a TestModel, not testModelInstance[GetEspReactRenderModelConsts.HandlerFunctionName]()
299
- return [model.modelIdViaModelGetter, model.valueViaModelGetter];
196
+ // here we're expecting to receive a TestModel, not testModelInstance[GetEspPolimerImmutableModelConsts.HandlerFunctionName]()
197
+ return [model.state.modelId, model.state.value];
300
198
  },
301
199
  modelSelectorOptions().setTryPreSelectPolimerImmutableModel(false)
302
200
  );
@@ -309,14 +207,11 @@ describe('useModelSelector', () => {
309
207
  };
310
208
 
311
209
  beforeEach(() => {
312
- setupModel(modelId);
313
- doRender(View, modelId);
210
+ api.setupModelAndRender(modelId, View);
314
211
  });
315
212
 
316
213
  it('selector passes router root model to selector', () => {
317
- // Not much to test here, it's really in the View logic for this case.
318
- // If the below passes, it means the selector was given the root ESP model.
319
- viewAsserts(renderResult)
214
+ api.asserts.view
320
215
  .modelIdIs(modelId)
321
216
  .valueIs('initial-value');
322
217
  });
@@ -334,26 +229,25 @@ describe('useModelSelector', () => {
334
229
  return;
335
230
  }
336
231
  return (
337
- <ViewMetadata modelId={model.modelIdViaModelGetter} modelValue={model.valueViaModelGetter} />
232
+ <ViewMetadata modelId={model.state.modelId} modelValue={model.state.value} />
338
233
  );
339
234
  };
340
235
 
341
236
  beforeEach(() => {
342
- setupModel(modelId);
343
- doRender(View, modelId);
237
+ api.setupModelAndRender(modelId, View);
344
238
  });
345
239
 
346
240
  it('view renders correct data', () => {
347
- viewAsserts(renderResult)
241
+ api.asserts.view
348
242
  .modelIdIs(modelId)
349
243
  .valueIs('initial-value');
350
244
  });
351
245
 
352
246
  it('Updates propagated', () => {
353
247
  act(() => {
354
- router.publishEvent(modelId, 'test-event', 'updated');
248
+ api.router.publishEvent(modelId, 'test-event', 'updated');
355
249
  });
356
- viewAsserts(renderResult)
250
+ api.asserts.view
357
251
  .modelIdIs(modelId)
358
252
  .valueIs('updated');
359
253
  });
@@ -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,21 +0,0 @@
1
- export interface GetEspReactRenderModelMetadata {
2
- functionName: string;
3
- }
4
- export declare namespace GetEspReactRenderModelConsts {
5
- const CustomDataKey = "GetEspReactRenderModelCustomDataKey";
6
- /**
7
- * 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
8
- */
9
- const HandlerFunctionName = "getEspReactRenderModel";
10
- }
11
- /**
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
- */
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 subgraph to use as state.
19
- *
20
- */
21
- export declare const tryGetRenderModel: <TRenderModel>(model: any) => TRenderModel;
@@ -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,50 +0,0 @@
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
- };
@@ -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 {tryGetRenderModel} from './polimer/getEspReactRenderModel';
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 renderModel = tryGetRenderModel<object>(model);
43
- const childProps: ViewBinderConnectableChildProps = {
44
- modelId,
45
- router: router,
46
- model: renderModel
47
- };
48
- let viewElement = createViewForModel(model, childProps, viewContext, view);
49
- return (
50
- <EspModelContextProvider modelId={modelId} router={router} model={renderModel} {...childProps}>
51
- {viewElement}
52
- </EspModelContextProvider>
53
- );
54
- };