esp-js-react 8.0.1-next.0 → 8.0.2-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/.dist/esp-react.js +32 -32
- package/.dist/esp-react.js.map +1 -1
- package/.dist/esp-react.min.js +1 -1
- package/.dist/esp-react.min.js.map +1 -1
- package/.dist/typings/index.d.ts +2 -2
- package/.dist/typings/polimer/getEspPolimerImmutableModel.d.ts +21 -0
- package/package.json +4 -4
- package/src/connectableComponent.tsx +2 -2
- package/src/index.ts +5 -5
- package/src/polimer/getEspPolimerImmutableModel.ts +50 -0
- package/src/useModelSelector.ts +2 -2
- package/src/viewBinderConnectable.tsx +4 -4
- package/tests/connectableComponentLegacyTests.tsx +23 -23
- package/tests/connectableComponentTests.tsx +419 -0
- package/tests/indexTests.ts +25 -91
- package/tests/testApi/asserts.ts +75 -0
- package/tests/testApi/testApi.tsx +84 -0
- package/tests/testApi/testModel.ts +37 -0
- package/tests/testApi/useStoreReceivedProps.ts +11 -0
- package/tests/testApi/viewMetadata.tsx +46 -0
- package/tests/useModelSelectorTests.tsx +45 -149
- package/.dist/typings/polimer/getEspReactRenderModel.d.ts +0 -21
- package/src/polimer/getEspReactRenderModel.ts +0 -50
- /package/.dist/typings/polimer/{polimerExtentsions.d.ts → polimerModelBuilderExtentsions.d.ts} +0 -0
- /package/src/polimer/{polimerExtentsions.ts → polimerModelBuilderExtentsions.ts} +0 -0
- /package/tests/{routerSpy.ts → testApi/routerSpy.ts} +0 -0
|
@@ -0,0 +1,84 @@
|
|
|
1
|
+
import {TestModel} from './testModel';
|
|
2
|
+
import {RouterSpy} from './routerSpy';
|
|
3
|
+
import {render, RenderResult} from '@testing-library/react';
|
|
4
|
+
import * as React from 'react';
|
|
5
|
+
import {EspModelContextProvider, EspRouterContextProvider} from '../../src';
|
|
6
|
+
import {PropAsserts, propAsserts, RouterAsserts, routerAsserts, ViewAsserts, viewAsserts} from './asserts';
|
|
7
|
+
import {isValidElement} from 'react';
|
|
8
|
+
import {TestPropStore, TestPropStoreContext} from './useStoreReceivedProps';
|
|
9
|
+
|
|
10
|
+
export type TestApi = {
|
|
11
|
+
router: RouterSpy;
|
|
12
|
+
asserts: {
|
|
13
|
+
router: RouterAsserts,
|
|
14
|
+
view: ViewAsserts,
|
|
15
|
+
props: PropAsserts,
|
|
16
|
+
};
|
|
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;
|
|
23
|
+
};
|
|
24
|
+
|
|
25
|
+
export const testApi = ()=> {
|
|
26
|
+
let router: RouterSpy = new RouterSpy();
|
|
27
|
+
let renderResult: RenderResult;
|
|
28
|
+
let propStore = new TestPropStore();
|
|
29
|
+
return {
|
|
30
|
+
router,
|
|
31
|
+
asserts: {
|
|
32
|
+
get router() {
|
|
33
|
+
return routerAsserts(router);
|
|
34
|
+
},
|
|
35
|
+
get view() {
|
|
36
|
+
return viewAsserts(renderResult);
|
|
37
|
+
},
|
|
38
|
+
get props() {
|
|
39
|
+
return propAsserts(propStore);
|
|
40
|
+
}
|
|
41
|
+
},
|
|
42
|
+
setupModelAndRender(modelId: string, view: React.ComponentType) {
|
|
43
|
+
this.setupModel(modelId);
|
|
44
|
+
this.doRender(view, modelId);
|
|
45
|
+
return this;
|
|
46
|
+
},
|
|
47
|
+
setupModel(modelId: string, alternativeModel?: object) {
|
|
48
|
+
const testModel = alternativeModel || new TestModel(modelId);
|
|
49
|
+
router.addModel(modelId, testModel);
|
|
50
|
+
router.observeEventsOn(modelId, testModel);
|
|
51
|
+
return this;
|
|
52
|
+
},
|
|
53
|
+
doRender(ComponentOrElement: any, modelIdForContext: string) {
|
|
54
|
+
let e: any = isValidElement(ComponentOrElement)
|
|
55
|
+
? ComponentOrElement
|
|
56
|
+
: (<ComponentOrElement />);
|
|
57
|
+
renderResult = render((
|
|
58
|
+
<TestPropStoreContext.Provider value={propStore}>
|
|
59
|
+
<EspRouterContextProvider router={router}>
|
|
60
|
+
<EspModelContextProvider modelId={modelIdForContext}>
|
|
61
|
+
{e},
|
|
62
|
+
</EspModelContextProvider>
|
|
63
|
+
</EspRouterContextProvider>
|
|
64
|
+
</TestPropStoreContext.Provider>
|
|
65
|
+
));
|
|
66
|
+
return this;
|
|
67
|
+
},
|
|
68
|
+
doReRender(ComponentOrElement: any, modelIdForContext: string) {
|
|
69
|
+
let componentOrElement: any = isValidElement(ComponentOrElement)
|
|
70
|
+
? ComponentOrElement
|
|
71
|
+
: (<ComponentOrElement />);
|
|
72
|
+
renderResult.rerender((
|
|
73
|
+
<TestPropStoreContext.Provider value={propStore}>
|
|
74
|
+
<EspRouterContextProvider router={router}>
|
|
75
|
+
<EspModelContextProvider modelId={modelIdForContext}>
|
|
76
|
+
{componentOrElement},
|
|
77
|
+
</EspModelContextProvider>
|
|
78
|
+
</EspRouterContextProvider>
|
|
79
|
+
</TestPropStoreContext.Provider>
|
|
80
|
+
));
|
|
81
|
+
return this;
|
|
82
|
+
}
|
|
83
|
+
} as TestApi;
|
|
84
|
+
};
|
|
@@ -0,0 +1,37 @@
|
|
|
1
|
+
import {observeEvent} from 'esp-js';
|
|
2
|
+
import {GetEspPolimerImmutableModelConsts} from '../../src';
|
|
3
|
+
|
|
4
|
+
export type TestModelImmutableState = { value: string, modelId: string };
|
|
5
|
+
|
|
6
|
+
export class TestModel {
|
|
7
|
+
|
|
8
|
+
private _internalState: TestModelImmutableState;
|
|
9
|
+
|
|
10
|
+
constructor(modelId: string) {
|
|
11
|
+
this._internalState = {
|
|
12
|
+
value: 'initial-value',
|
|
13
|
+
modelId: modelId,
|
|
14
|
+
};
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
public get valueViaModelGetter() {
|
|
18
|
+
return this._internalState.value;
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
public get modelIdViaModelGetter() {
|
|
22
|
+
return this._internalState.modelId;
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
@observeEvent('test-event')
|
|
26
|
+
_onTestEvent(ev: string) {
|
|
27
|
+
// mimic some immutable logic that would be provided by a lib such as immer in a real app.
|
|
28
|
+
this._internalState = {
|
|
29
|
+
...this._internalState,
|
|
30
|
+
value: ev
|
|
31
|
+
};
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
[GetEspPolimerImmutableModelConsts.HandlerFunctionName]: () => TestModelImmutableState = () => {
|
|
35
|
+
return this._internalState;
|
|
36
|
+
};
|
|
37
|
+
}
|
|
@@ -0,0 +1,11 @@
|
|
|
1
|
+
import {createContext, useContext} from 'react';
|
|
2
|
+
|
|
3
|
+
export const TestPropStoreContext = createContext<TestPropStore>(null);
|
|
4
|
+
export const useTestPropStore = () => useContext(TestPropStoreContext);
|
|
5
|
+
|
|
6
|
+
export class TestPropStore {
|
|
7
|
+
receivedProps: any[] = [];
|
|
8
|
+
pushProps(props: any) {
|
|
9
|
+
this.receivedProps.push(props);
|
|
10
|
+
}
|
|
11
|
+
}
|
|
@@ -0,0 +1,46 @@
|
|
|
1
|
+
import * as React from 'react';
|
|
2
|
+
import {utils} from 'esp-js';
|
|
3
|
+
|
|
4
|
+
/**
|
|
5
|
+
* This is a bit of a hack to get the types and values of props passed into our HOC.
|
|
6
|
+
*
|
|
7
|
+
* React testing library doesn't have a lot of hooks for this, and generally you don't need to write HOC in modern React.
|
|
8
|
+
* However we need to support legacy code that uses the prop passing via HOC patterns.
|
|
9
|
+
* This function helps parse the props into attributes we can put on the DOM to asserts they are flowing through.
|
|
10
|
+
*/
|
|
11
|
+
const getPropsAsDataAttributesWithMetadata = (props: any) => {
|
|
12
|
+
const propsAsDataAttributes: {[key: string]: string} = Object.keys(props).reduce((result: any, key: string) => {
|
|
13
|
+
let prop = props[key];
|
|
14
|
+
let value: string;
|
|
15
|
+
if (utils.isString(prop)) {
|
|
16
|
+
value = prop;
|
|
17
|
+
} else if (utils.isFunction(props)) {
|
|
18
|
+
value = 'function';
|
|
19
|
+
} else if (utils.isObject(props)) {
|
|
20
|
+
value = 'object';
|
|
21
|
+
} else {
|
|
22
|
+
value = String(props);
|
|
23
|
+
}
|
|
24
|
+
// need to lower case data-* attributes else React throws a warning
|
|
25
|
+
result[`data-${key.toLowerCase()}`] = value;
|
|
26
|
+
return result;
|
|
27
|
+
}, {});
|
|
28
|
+
return propsAsDataAttributes;
|
|
29
|
+
};
|
|
30
|
+
|
|
31
|
+
type ViewMetadataProps = {
|
|
32
|
+
modelId: string,
|
|
33
|
+
modelValue: string
|
|
34
|
+
[key: string]: string; // ...rest props
|
|
35
|
+
};
|
|
36
|
+
|
|
37
|
+
export const ViewMetadata = (props: ViewMetadataProps) => {
|
|
38
|
+
const { modelId, modelValue, ...rest} = props;
|
|
39
|
+
return (
|
|
40
|
+
<div>
|
|
41
|
+
<span data-testid='modelIdDisplay'>{modelId}</span>
|
|
42
|
+
<span data-testid='valueDisplay'>{modelValue}</span>
|
|
43
|
+
<span data-testid='span-with-props-as-attributes' {...getPropsAsDataAttributesWithMetadata(rest)} />
|
|
44
|
+
</div>
|
|
45
|
+
);
|
|
46
|
+
};
|
|
@@ -1,126 +1,26 @@
|
|
|
1
1
|
import 'jest';
|
|
2
2
|
import * as React from 'react';
|
|
3
3
|
import {act} from 'react';
|
|
4
|
-
import {
|
|
5
|
-
import {
|
|
6
|
-
import {
|
|
7
|
-
|
|
8
|
-
import '
|
|
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/viewMetadata';
|
|
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
|
|
87
|
-
renderResult: RenderResult;
|
|
13
|
+
let api: TestApi;
|
|
88
14
|
|
|
89
15
|
beforeEach(() => {
|
|
90
|
-
|
|
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<
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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<
|
|
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.setupModel(modelId);
|
|
74
|
+
api.doRender(View, undefined);
|
|
176
75
|
});
|
|
177
76
|
|
|
178
77
|
it('renders correct model data', () => {
|
|
179
|
-
|
|
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<
|
|
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
|
-
|
|
211
|
-
doRender(View, modelId);
|
|
109
|
+
api.setupModelAndRender(modelId, View);
|
|
212
110
|
});
|
|
213
111
|
|
|
214
112
|
it('renders initial model data', () => {
|
|
215
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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<
|
|
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.setupModel(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
|
-
|
|
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
|
-
|
|
169
|
+
api.asserts.view
|
|
272
170
|
.modelIdIs(modelId1)
|
|
273
171
|
.valueIs('initial-value');
|
|
274
|
-
doReRender(View, undefined);
|
|
275
|
-
|
|
172
|
+
api.doReRender(View, undefined);
|
|
173
|
+
api.asserts.view
|
|
276
174
|
.modelIdIs('')
|
|
277
175
|
.valueIs('');
|
|
278
|
-
setupModel(modelId2);
|
|
279
|
-
doReRender(View, modelId2);
|
|
280
|
-
|
|
176
|
+
api.setupModel(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
|
-
|
|
184
|
+
api.asserts.view
|
|
287
185
|
.modelIdIs(modelId2)
|
|
288
186
|
.valueIs('updated');
|
|
289
187
|
});
|
|
@@ -295,7 +193,7 @@ 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[
|
|
196
|
+
// here we're expecting to receive a TestModel, not testModelInstance[GetEspPolimerImmutableModelConsts.HandlerFunctionName]()
|
|
299
197
|
return [model.modelIdViaModelGetter, model.valueViaModelGetter];
|
|
300
198
|
},
|
|
301
199
|
modelSelectorOptions().setTryPreSelectPolimerImmutableModel(false)
|
|
@@ -309,14 +207,13 @@ describe('useModelSelector', () => {
|
|
|
309
207
|
};
|
|
310
208
|
|
|
311
209
|
beforeEach(() => {
|
|
312
|
-
|
|
313
|
-
doRender(View, modelId);
|
|
210
|
+
api.setupModelAndRender(modelId, View);
|
|
314
211
|
});
|
|
315
212
|
|
|
316
213
|
it('selector passes router root model to selector', () => {
|
|
317
214
|
// Not much to test here, it's really in the View logic for this case.
|
|
318
215
|
// If the below passes, it means the selector was given the root ESP model.
|
|
319
|
-
|
|
216
|
+
api.asserts.view
|
|
320
217
|
.modelIdIs(modelId)
|
|
321
218
|
.valueIs('initial-value');
|
|
322
219
|
});
|
|
@@ -339,21 +236,20 @@ describe('useModelSelector', () => {
|
|
|
339
236
|
};
|
|
340
237
|
|
|
341
238
|
beforeEach(() => {
|
|
342
|
-
|
|
343
|
-
doRender(View, modelId);
|
|
239
|
+
api.setupModelAndRender(modelId, View);
|
|
344
240
|
});
|
|
345
241
|
|
|
346
242
|
it('view renders correct data', () => {
|
|
347
|
-
|
|
243
|
+
api.asserts.view
|
|
348
244
|
.modelIdIs(modelId)
|
|
349
245
|
.valueIs('initial-value');
|
|
350
246
|
});
|
|
351
247
|
|
|
352
248
|
it('Updates propagated', () => {
|
|
353
249
|
act(() => {
|
|
354
|
-
router.publishEvent(modelId, 'test-event', 'updated');
|
|
250
|
+
api.router.publishEvent(modelId, 'test-event', 'updated');
|
|
355
251
|
});
|
|
356
|
-
|
|
252
|
+
api.asserts.view
|
|
357
253
|
.modelIdIs(modelId)
|
|
358
254
|
.valueIs('updated');
|
|
359
255
|
});
|
|
@@ -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,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
|
-
};
|
/package/.dist/typings/polimer/{polimerExtentsions.d.ts → polimerModelBuilderExtentsions.d.ts}
RENAMED
|
File without changes
|
|
File without changes
|
|
File without changes
|