esp-js-react 8.0.0-next.0 → 8.0.1-next.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/index.ts CHANGED
@@ -44,31 +44,37 @@ export {
44
44
  ConnectableComponent,
45
45
  } from './connectableComponent';
46
46
  export {
47
+ UseModelSelector,
47
48
  useModelSelector,
48
- ConnectEqualityFn,
49
- defaultConnectEqualityFn
49
+ EditableModelSelectorOptions,
50
+ modelSelectorOptions,
51
+ ModelSelectorOptions,
52
+ ModelSelectorEqualityFn,
50
53
  } from './useModelSelector';
51
54
  export {
52
55
  RouterProvider,
53
56
  RouterProviderProps,
54
- EspRouterContext,
55
- EspRouterContextProps,
57
+ EspRouterContextProvider,
58
+ EspRouterContextProviderProps,
56
59
  RouterContext,
57
60
  useRouter,
58
61
  PublishEventDelegate,
59
62
  PublishEventContext,
60
63
  usePublishEvent,
61
- } from './espRouterContext';
64
+ } from './espRouterContextProvider';
62
65
  export {
63
66
  useGetModelId,
64
67
  GetModelIdDelegate,
65
68
  GetModelIdContext,
69
+ useGetModel,
70
+ GetModelDelegate,
71
+ GetModelContext,
66
72
  PublishModelEventDelegate,
67
73
  PublishModelEventContext,
68
74
  usePublishModelEvent,
69
75
  PublishModelEventWithEntityKeyDelegate,
70
76
  PublishModelEventWithEntityKeyContext,
71
77
  usePublishModelEventWithEntityKey,
72
- EspModelContext,
73
- EspModelContextProps,
74
- } from './espModelContext';
78
+ EspModelContextProvider,
79
+ EspModelContextProviderProps,
80
+ } from './espModelContextProvider';
@@ -29,7 +29,7 @@ export function getEspReactRenderModel() {
29
29
  /**
30
30
  * Returns the model which will be used to pluck state/props for the current view.
31
31
  *
32
- * 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.
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
33
  *
34
34
  */
35
35
  export const tryGetRenderModel = <TRenderModel>(model: any): TRenderModel => {
@@ -1,13 +1,64 @@
1
1
  import {useMemo} from 'react';
2
- import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/with-selector';
3
- import {Guard} from 'esp-js';
4
- import {useRouter} from './espRouterContext';
5
- import {useGetModelId} from './espModelContext';
2
+ import {useSyncExternalStoreWithSelector} from 'use-sync-external-store/with-selector';
3
+ import {Guard, utils} from 'esp-js';
4
+ import {useRouter} from './espRouterContextProvider';
5
+ import {useGetModelId} from './espModelContextProvider';
6
6
  import {tryGetRenderModel} from './polimer/getEspReactRenderModel';
7
7
 
8
- export const defaultConnectEqualityFn = <TSelected>(a: TSelected, b: TSelected) => a === b; // reference equality
8
+ export type ModelSelectorEqualityFn<T> = (last: T, next: T) => boolean;
9
9
 
10
- export type ConnectEqualityFn<T> = (last: T, next: T) => boolean;
10
+ /**
11
+ * @param modelId - the modelId of the model to be observed via the esp Router.
12
+ * @param tryPreSelectPolimerImmutableModel - if true, and the esp model is an esp-js-polimer model, the immutable model will be used when calling the selector.
13
+ * @param equalityFn - Equality function which will be applied against TSelected, defaults to instance equality (a === b).
14
+ */
15
+ export type ModelSelectorOptions<TSelected> = {
16
+ modelId?: string,
17
+ tryPreSelectPolimerImmutableModel: boolean,
18
+ equalityFn: ModelSelectorEqualityFn<TSelected>
19
+ };
20
+
21
+ export interface EditableModelSelectorOptions<TSelected> extends ModelSelectorOptions<TSelected> {
22
+ setModelId(modelId: string): this;
23
+
24
+ setTryPreSelectPolimerImmutableModel(value: boolean): this;
25
+
26
+ setEqualityFn(fn: (a: TSelected, b: TSelected) => boolean): this;
27
+ }
28
+
29
+ export const modelSelectorOptions = <TSelected>() => {
30
+ let modelId = undefined;
31
+ let equalityFn: ModelSelectorEqualityFn<TSelected> = (a: TSelected, b: TSelected) => a === b;
32
+ let tryPreSelectPolimerImmutableModel = true;
33
+ return {
34
+ get modelId() {
35
+ return modelId;
36
+ },
37
+ setModelId(value: string) {
38
+ modelId = value;
39
+ return this;
40
+ },
41
+ get equalityFn() {
42
+ return equalityFn;
43
+ },
44
+ setEqualityFn(value: ModelSelectorEqualityFn<TSelected>) {
45
+ equalityFn = value;
46
+ return this;
47
+ },
48
+ get tryPreSelectPolimerImmutableModel() {
49
+ return tryPreSelectPolimerImmutableModel;
50
+ },
51
+ setTryPreSelectPolimerImmutableModel(value: boolean) {
52
+ tryPreSelectPolimerImmutableModel = value;
53
+ return this;
54
+ }
55
+ } as EditableModelSelectorOptions<TSelected>;
56
+ };
57
+
58
+ export type UseModelSelector = <TModel, TSelected>(
59
+ selector: (model: TModel) => TSelected,
60
+ options?: ModelSelectorOptions<TSelected>
61
+ ) => TSelected;
11
62
 
12
63
  /**
13
64
  * A hook which returns model state from the esp Router.
@@ -15,19 +66,17 @@ export type ConnectEqualityFn<T> = (last: T, next: T) => boolean;
15
66
  * This hooks wih observe updates and re-render the component if the model changes.
16
67
  *
17
68
  * @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.
18
- * @param modelId - the modelId of the model to be observed via the esp Router.
19
- * @param tryPreSelectPolimerImmutableModel - if true, and the esp model is an esp-js-polimer model, the immutable model will be used when calling the selector.
20
- * @param equalityFn - Equality function which will be applied against TSelected, defaults to instance equality (a === b).
69
+ * @param options
21
70
  */
22
- export const useModelSelector = <TModel = unknown, TSelected = unknown>(
71
+ export const useModelSelector: UseModelSelector = <TModel, TSelected>(
23
72
  selector: (model: TModel) => TSelected,
24
- modelId?: string,
25
- tryPreSelectPolimerImmutableModel: boolean = true,
26
- equalityFn: ConnectEqualityFn<TSelected> = defaultConnectEqualityFn
73
+ options: ModelSelectorOptions<TSelected> = modelSelectorOptions<TSelected>()
27
74
  ) => {
28
75
  Guard.isFunction(selector, 'You must pass a selector function to connectSelector');
29
76
  const router = useRouter();
30
- modelId = modelId || useGetModelId();
77
+ const modelId = options?.modelId || useGetModelId();
78
+ const tryPreSelectPolimerImmutableModel = options?.tryPreSelectPolimerImmutableModel;
79
+ const equalityFn = options?.equalityFn;
31
80
  const dependencies = useMemo(
32
81
  () => {
33
82
  // Because of how useSyncExternalStore works, there is an implicit dependency between the subscribe and getSnapshot functions.
@@ -64,10 +113,7 @@ export const useModelSelector = <TModel = unknown, TSelected = unknown>(
64
113
  return model;
65
114
  },
66
115
  // While getSnapshot needs to model to be immutable,
67
-
68
- // TODO confirm this comment with a test:
69
-
70
- // useSyncExternalStoreWithSelector builds on top of this so the TSelected can defer to an equality check to determine if the change is propagated.
116
+ // useSyncExternalStoreWithSelector builds on top of this, so the TSelected can defer to an equality check to determine if the change is propagated.
71
117
  // The selector here just maps the TSelected, useSyncExternalStoreWithSelector internally does the equality check.
72
118
  wrappedSelector: (snapshot: TModel) => {
73
119
  // The first time this renders, react calls getSnapshot and the selector before the router has pushed a change.
@@ -81,6 +127,19 @@ export const useModelSelector = <TModel = unknown, TSelected = unknown>(
81
127
  // Don't cache check against 'selector' argument as that will likely change unless the caller memoizes it.
82
128
  [router, modelId]
83
129
  );
130
+
131
+ // If we don't have a modelId, we still need to return a hook so React doesn't complain.
132
+ // Additionally, we need to let the above expiration (dependencies) run to unsubscribe from any previous subscription.
133
+ if (utils.stringIsEmpty(modelId)) {
134
+ return useSyncExternalStoreWithSelector(
135
+ noopSubscription.subscribe,
136
+ noopSubscription.getSnapshot,
137
+ undefined,
138
+ noopSubscription.wrappedSelector,
139
+ equalityFn
140
+ );
141
+ }
142
+
84
143
  // Docs on useSyncExternalStore https://github.com/reactwg/react-18/discussions/86
85
144
  // Redux's usage of this: https://github.com/reduxjs/react-redux/blob/master/src/hooks/useSelector.ts
86
145
  // Code: https://github.com/facebook/react/blob/main/packages/use-sync-external-store/src/useSyncExternalStoreWithSelector.js
@@ -91,4 +150,10 @@ export const useModelSelector = <TModel = unknown, TSelected = unknown>(
91
150
  dependencies.wrappedSelector,
92
151
  equalityFn,
93
152
  );
153
+ };
154
+
155
+ const noopSubscription = {
156
+ subscribe: () => { },
157
+ getSnapshot: () => null,
158
+ wrappedSelector: () => true
94
159
  };
@@ -18,7 +18,7 @@
18
18
 
19
19
  import * as React from 'react';
20
20
  import {createViewForModel} from './viewBindingDecorator';
21
- import {useRouter} from './espRouterContext';
21
+ import {useRouter} from './espRouterContextProvider';
22
22
 
23
23
  export interface ViewBinderProps {
24
24
  model: any;
@@ -1,8 +1,8 @@
1
- import {useRouter} from './espRouterContext';
2
- import {EspModelContext} from './espModelContext';
1
+ import {useRouter} from './espRouterContextProvider';
2
+ import {EspModelContextProvider} from './espModelContextProvider';
3
3
  import {Logger, Router} from 'esp-js';
4
4
  import * as React from 'react';
5
- import {useModelSelector} from './useModelSelector';
5
+ import {modelSelectorOptions, useModelSelector} from './useModelSelector';
6
6
  import {createViewForModel} from './viewBindingDecorator';
7
7
  import {tryGetRenderModel} from './polimer/getEspReactRenderModel';
8
8
 
@@ -32,8 +32,9 @@ export const ViewBinderConnectable = ({modelId, viewContext, view}: ViewBinderCo
32
32
  const router = useRouter();
33
33
  const model = useModelSelector<object, object>(
34
34
  m => m,
35
- modelId,
36
- false
35
+ modelSelectorOptions()
36
+ .setModelId(modelId)
37
+ .setTryPreSelectPolimerImmutableModel(false)
37
38
  );
38
39
  if (!model) {
39
40
  return null;
@@ -46,8 +47,8 @@ export const ViewBinderConnectable = ({modelId, viewContext, view}: ViewBinderCo
46
47
  };
47
48
  let viewElement = createViewForModel(model, childProps, viewContext, view);
48
49
  return (
49
- <EspModelContext modelId={modelId} router={router} model={renderModel} {...childProps}>
50
+ <EspModelContextProvider modelId={modelId} router={router} model={renderModel} {...childProps}>
50
51
  {viewElement}
51
- </EspModelContext>
52
+ </EspModelContextProvider>
52
53
  );
53
54
  };
@@ -8,7 +8,7 @@ import {
8
8
  getEspReactRenderModel,
9
9
  PublishModelEventDelegate,
10
10
  RouterContext,
11
- EspRouterContext
11
+ EspRouterContextProvider
12
12
  } from '../src';
13
13
  import {Router, observeEvent, utils} from 'esp-js';
14
14
  import {render, RenderResult} from '@testing-library/react';
@@ -177,14 +177,14 @@ describe('ConnectableComponent', () => {
177
177
  );
178
178
  } else {
179
179
  renderResult = render(
180
- <EspRouterContext router={router} >
180
+ <EspRouterContextProvider router={router} >
181
181
  <ConnectableComponent
182
182
  {...connectableComponentProps}
183
183
  mapModelToProps={mapModelToProps}
184
184
  viewContext={userAlternativeViewContext}
185
185
  {...otherProps}
186
186
  />
187
- </EspRouterContext>
187
+ </EspRouterContextProvider>
188
188
  );
189
189
  }
190
190
  }
@@ -0,0 +1,24 @@
1
+ import {Router, Observable} from 'esp-js';
2
+
3
+ export class RouterSpy extends Router {
4
+ private _modelSubscriptionCountByModelId = new Map<string, number>();
5
+
6
+ public getSubscriberCount(modelId: string) {
7
+ return this._modelSubscriptionCountByModelId.get(modelId);
8
+ }
9
+
10
+ public getModelObservable<TModel>(modelId: string): Observable<TModel> {
11
+ return Observable.create(o => {
12
+ let c1 = this._modelSubscriptionCountByModelId.get(modelId) || 0;
13
+ c1++;
14
+ this._modelSubscriptionCountByModelId.set(modelId, c1);
15
+ let subscription = super.getModelObservable(modelId).subscribe(o);
16
+ return () => {
17
+ let c2 = this._modelSubscriptionCountByModelId.get(modelId);
18
+ c2--;
19
+ this._modelSubscriptionCountByModelId.set(modelId, c2);
20
+ subscription.dispose();
21
+ };
22
+ });
23
+ }
24
+ }
@@ -0,0 +1,361 @@
1
+ import 'jest';
2
+ import * as React from 'react';
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
+ };
82
+
83
+ type SelectedObject = { id: string, value: string };
84
+
85
+ describe('useModelSelector', () => {
86
+ let router: RouterSpy,
87
+ renderResult: RenderResult;
88
+
89
+ beforeEach(() => {
90
+ router = new RouterSpy();
91
+ });
92
+
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
+ describe('Default API case', () => {
120
+ const modelId = 'modelId';
121
+
122
+ const View = () => {
123
+ const valuesObj = useModelSelector<TestModelImmutableStateState, SelectedObject>(
124
+ model => {
125
+ return {id: model.modelId, value: model.value};
126
+ },
127
+ );
128
+ if (!valuesObj) {
129
+ return;
130
+ }
131
+ return (
132
+ <ViewMetadata modelId={valuesObj.id} modelValue={valuesObj.value} />
133
+ );
134
+ };
135
+
136
+ beforeEach(() => {
137
+ setupModel(modelId);
138
+ doRender(View, modelId);
139
+ });
140
+
141
+ it('renders immutable model based on modelId found on context', () => {
142
+ viewAsserts(renderResult)
143
+ .modelIdIs(modelId)
144
+ .valueIs('initial-value');
145
+ });
146
+
147
+ it('updates are rendered', () => {
148
+ act(() => {
149
+ router.publishEvent(modelId, 'test-event', 'new-value');
150
+ });
151
+ viewAsserts(renderResult)
152
+ .modelIdIs(modelId)
153
+ .valueIs('new-value');
154
+ });
155
+ });
156
+
157
+ describe('modelId can be passed via selector', () => {
158
+ const modelId = 'modelId';
159
+
160
+ const View = () => {
161
+ const values: string[] = useModelSelector<TestModelImmutableStateState, string[]>(
162
+ model => [model.modelId, model.value],
163
+ modelSelectorOptions().setModelId(modelId)
164
+ );
165
+ if (!values) {
166
+ return;
167
+ }
168
+ return (
169
+ <ViewMetadata modelId={values[0]} modelValue={values[1]} />
170
+ );
171
+ };
172
+
173
+ beforeEach(() => {
174
+ setupModel(modelId);
175
+ doRender(View, undefined);
176
+ });
177
+
178
+ it('renders correct model data', () => {
179
+ viewAsserts(renderResult)
180
+ .modelIdIs(modelId)
181
+ .valueIs('initial-value');
182
+ });
183
+ });
184
+
185
+ describe('equalityFn is invoked to determine if changed should be propagated', () => {
186
+ const modelId = 'modelId';
187
+
188
+ const View = () => {
189
+ const values = useModelSelector<TestModelImmutableStateState, SelectedObject>(
190
+ model => ({id: model.modelId, value: model.value}),
191
+ modelSelectorOptions<SelectedObject>()
192
+ .setEqualityFn((a, b) => {
193
+ if (!a) {
194
+ return false; // first time
195
+ }
196
+ // delegate to model, set via the test, to see if we're 'equal'
197
+ // If this returns true, useModelSelector internally assume the last snapshot is the same thus doesn't propagate the last snapshot.
198
+ return b.value === 'assume-no-change';
199
+ })
200
+ );
201
+ if (!values) {
202
+ return;
203
+ }
204
+ return (
205
+ <ViewMetadata modelId={values.id} modelValue={values.value} />
206
+ );
207
+ };
208
+
209
+ beforeEach(() => {
210
+ setupModel(modelId);
211
+ doRender(View, modelId);
212
+ });
213
+
214
+ it('renders initial model data', () => {
215
+ viewAsserts(renderResult)
216
+ .modelIdIs(modelId)
217
+ .valueIs('initial-value');
218
+ });
219
+
220
+ it('updates are ignored due to equalityFn', () => {
221
+ viewAsserts(renderResult)
222
+ .modelIdIs(modelId)
223
+ .valueIs('initial-value');
224
+ act(() => {
225
+ router.publishEvent(modelId, 'test-event', 'assume-no-change');
226
+ });
227
+ viewAsserts(renderResult)
228
+ .modelIdIs(modelId)
229
+ .valueIs('initial-value'); // event data WAS NOT propagated
230
+ act(() => {
231
+ router.publishEvent(modelId, 'test-event', 'do-change');
232
+ });
233
+ viewAsserts(renderResult)
234
+ .modelIdIs(modelId)
235
+ .valueIs('do-change'); // event data WAS propagated
236
+ });
237
+ });
238
+
239
+ describe('selector internal caching is based on modelId', () => {
240
+ const modelId1 = 'modelId1';
241
+ const modelId2 = 'modelId2';
242
+
243
+ const View = (props: {modelId: string}) => {
244
+ const values = useModelSelector<TestModelImmutableStateState, SelectedObject>(
245
+ model => ({id: model.modelId, value: model.value}),
246
+ modelSelectorOptions().setModelId(props.modelId)
247
+ );
248
+ if (!values) {
249
+ return;
250
+ }
251
+ return (
252
+ <ViewMetadata modelId={values.id} modelValue={values.value} />
253
+ );
254
+ };
255
+
256
+ beforeEach(() => {
257
+ setupModel(modelId1);
258
+ doRender(View, modelId1);
259
+ });
260
+
261
+ it('selector subscribed to Router', () => {
262
+ routerAsserts(router).subscriberCountIs(modelId1, 1);
263
+ });
264
+
265
+ it('unsubscribes when modelId changes', () => {
266
+ doReRender(View, undefined);
267
+ routerAsserts(router).subscriberCountIs(modelId1, 0);
268
+ });
269
+
270
+ it('resubscribes to new model when modelId changes', () => {
271
+ viewAsserts(renderResult)
272
+ .modelIdIs(modelId1)
273
+ .valueIs('initial-value');
274
+ doReRender(View, undefined);
275
+ viewAsserts(renderResult)
276
+ .modelIdIs('')
277
+ .valueIs('');
278
+ setupModel(modelId2);
279
+ doReRender(View, modelId2);
280
+ viewAsserts(renderResult)
281
+ .modelIdIs(modelId2)
282
+ .valueIs('initial-value');
283
+ act(() => {
284
+ router.publishEvent(modelId2, 'test-event', 'updated');
285
+ });
286
+ viewAsserts(renderResult)
287
+ .modelIdIs(modelId2)
288
+ .valueIs('updated');
289
+ });
290
+ });
291
+
292
+ describe('non immutable model cases #1 - selector receives then maps model subset', () => {
293
+ const modelId = 'modelId';
294
+
295
+ const View = () => {
296
+ const values: string[] = useModelSelector<TestModel, string[]>(
297
+ model => {
298
+ // here we're expecting to receive a TestModel, not testModelInstance[GetEspReactRenderModelConsts.HandlerFunctionName]()
299
+ return [model.modelIdViaModelGetter, model.valueViaModelGetter];
300
+ },
301
+ modelSelectorOptions().setTryPreSelectPolimerImmutableModel(false)
302
+ );
303
+ if (!values) {
304
+ return;
305
+ }
306
+ return (
307
+ <ViewMetadata modelId={values[0]} modelValue={values[1]} />
308
+ );
309
+ };
310
+
311
+ beforeEach(() => {
312
+ setupModel(modelId);
313
+ doRender(View, modelId);
314
+ });
315
+
316
+ 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)
320
+ .modelIdIs(modelId)
321
+ .valueIs('initial-value');
322
+ });
323
+ });
324
+
325
+ describe('non immutable model cases - selector maps root model', () => {
326
+ const modelId = 'modelId';
327
+
328
+ const View = () => {
329
+ const model: TestModel = useModelSelector<TestModel, TestModel>(
330
+ m => m,
331
+ modelSelectorOptions().setTryPreSelectPolimerImmutableModel(false)
332
+ );
333
+ if (!model) {
334
+ return;
335
+ }
336
+ return (
337
+ <ViewMetadata modelId={model.modelIdViaModelGetter} modelValue={model.valueViaModelGetter} />
338
+ );
339
+ };
340
+
341
+ beforeEach(() => {
342
+ setupModel(modelId);
343
+ doRender(View, modelId);
344
+ });
345
+
346
+ it('view renders correct data', () => {
347
+ viewAsserts(renderResult)
348
+ .modelIdIs(modelId)
349
+ .valueIs('initial-value');
350
+ });
351
+
352
+ it('Updates propagated', () => {
353
+ act(() => {
354
+ router.publishEvent(modelId, 'test-event', 'updated');
355
+ });
356
+ viewAsserts(renderResult)
357
+ .modelIdIs(modelId)
358
+ .valueIs('updated');
359
+ });
360
+ });
361
+ });