esp-js-react 7.0.2 → 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.
Files changed (43) hide show
  1. package/.dist/esp-react.js +468 -511
  2. package/.dist/esp-react.js.map +1 -1
  3. package/.dist/esp-react.min.js +2 -1
  4. package/.dist/esp-react.min.js.LICENSE.txt +9 -0
  5. package/.dist/esp-react.min.js.map +1 -1
  6. package/.dist/typings/connect.d.ts +12 -0
  7. package/.dist/typings/connectableComponent.d.ts +20 -46
  8. package/.dist/typings/{espModelContext.d.ts → espModelContextProvider.d.ts} +8 -9
  9. package/.dist/typings/espRouterContextProvider.d.ts +47 -0
  10. package/.dist/typings/index.d.ts +7 -6
  11. package/.dist/typings/{getEspReactRenderModel.d.ts → polimer/getEspReactRenderModel.d.ts} +7 -0
  12. package/.dist/typings/useModelSelector.d.ts +27 -0
  13. package/.dist/typings/viewBinder.d.ts +1 -8
  14. package/.dist/typings/viewBinderConnectable.d.ts +15 -0
  15. package/.dist/typings/viewBindingDecorator.d.ts +1 -2
  16. package/package.json +7 -6
  17. package/src/connect.tsx +31 -0
  18. package/src/connectableComponent.tsx +94 -190
  19. package/src/espModelContextProvider.tsx +95 -0
  20. package/src/espRouterContextProvider.tsx +88 -0
  21. package/src/index.ts +40 -18
  22. package/src/polimer/getEspReactRenderModel.ts +50 -0
  23. package/src/useModelSelector.ts +159 -0
  24. package/src/viewBinder.tsx +14 -22
  25. package/src/viewBinderConnectable.tsx +54 -0
  26. package/src/viewBindingDecorator.ts +2 -3
  27. package/tests/connectableComponentLegacyTests.tsx +405 -0
  28. package/tests/indexTests.ts +0 -12
  29. package/tests/routerSpy.ts +24 -0
  30. package/tests/useModelSelectorTests.tsx +361 -0
  31. package/.dist/typings/routerProvider.d.ts +0 -18
  32. package/.dist/typings/shallowEqual.d.ts +0 -21
  33. package/.dist/typings/shouldUpdateMixin.d.ts +0 -10
  34. package/.dist/typings/smartComponent.d.ts +0 -33
  35. package/.dist/typings/utils.d.ts +0 -5
  36. package/src/espModelContext.tsx +0 -69
  37. package/src/getEspReactRenderModel.ts +0 -27
  38. package/src/routerProvider.tsx +0 -47
  39. package/src/shallowEqual.ts +0 -70
  40. package/src/shouldUpdateMixin.ts +0 -73
  41. package/src/smartComponent.tsx +0 -93
  42. package/src/utils.ts +0 -61
  43. package/tests/connectableComponentTests.tsx +0 -390
@@ -18,12 +18,10 @@
18
18
 
19
19
  import * as espReact from '../src/index';
20
20
  import {
21
- SmartComponent,
22
21
  ViewBinder,
23
22
  viewBinding,
24
23
  getEspReactRenderModel,
25
24
  GetEspReactRenderModelConsts,
26
- shouldUpdateMixin,
27
25
 
28
26
  useRouter,
29
27
  RouterContext,
@@ -53,11 +51,6 @@ describe('index exports', () => {
53
51
  expect(RouterContext).toBeDefined();
54
52
  });
55
53
 
56
- it('should export SmartComponent', () => {
57
- expect(espReact.SmartComponent).toBeDefined();
58
- expect(SmartComponent).toBeDefined();
59
- });
60
-
61
54
  it('should export ViewBinder', () => {
62
55
  expect(espReact.ViewBinder).toBeDefined();
63
56
  expect(ViewBinder).toBeDefined();
@@ -78,11 +71,6 @@ describe('index exports', () => {
78
71
  expect(GetEspReactRenderModelConsts).toBeDefined();
79
72
  });
80
73
 
81
- it('should export shouldUpdateMixin', () => {
82
- expect(espReact.shouldUpdateMixin).toBeDefined();
83
- expect(shouldUpdateMixin).toBeDefined();
84
- });
85
-
86
74
  describe('hooks', () => {
87
75
 
88
76
  it('should export useRouter and related', () => {
@@ -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
+ });
@@ -1,18 +0,0 @@
1
- import * as React from 'react';
2
- import * as PropTypes from 'prop-types';
3
- import { Router } from 'esp-js';
4
- export interface RouterProviderProps {
5
- router: Router;
6
- children: any;
7
- }
8
- export declare const RouterContext: React.Context<Router>;
9
- export declare const useRouter: () => Router;
10
- export declare class RouterProvider extends React.Component<RouterProviderProps, any> {
11
- static childContextTypes: {
12
- router: PropTypes.Validator<Router>;
13
- };
14
- getChildContext(): {
15
- router: Router;
16
- };
17
- render(): React.JSX.Element;
18
- }
@@ -1,21 +0,0 @@
1
- /**
2
- * Copyright (c) 2013-present, Facebook, Inc.
3
- *
4
- * This source code is licensed under the MIT license found in the
5
- * LICENSE file in the root directory of this source tree.
6
- *
7
- * @providesModule shallowEqual
8
- * @typechecks
9
- * @flow
10
- */
11
- /**
12
- * inlined Object.is polyfill to avoid requiring consumers ship their own
13
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
14
- */
15
- export declare function is(x: any, y: any): boolean;
16
- /**
17
- * Performs equality by iterating through keys on an object and returning false
18
- * when any key has values which are not strictly equal between the arguments.
19
- * Returns true when the values of all keys are strictly equal.
20
- */
21
- export declare function shallowEqual(objA: any, objB: any): boolean;
@@ -1,10 +0,0 @@
1
- import * as React from 'react';
2
- export declare function shouldUpdateMixin<TProps, TState, TPropBindings>(itemsThatEffectUpdateSelector: (nextProps: TProps) => TPropBindings): <TConstructor extends {
3
- new (...args: any[]): {};
4
- }>(Constructor: TConstructor) => {
5
- new (...args: any[]): {
6
- _propBindings: {};
7
- shouldComponentUpdate(nextProps: any, nextState: any): boolean;
8
- render(): React.CElement<any, React.Component<any, any, any>>;
9
- };
10
- } & TConstructor;
@@ -1,33 +0,0 @@
1
- import * as React from 'react';
2
- import * as PropTypes from 'prop-types';
3
- import { Router } from 'esp-js';
4
- export interface SmartComponentProps {
5
- modelId: string;
6
- view?: any;
7
- viewContext?: string;
8
- modelSelector?: (model: any) => any;
9
- [key: string]: any;
10
- }
11
- export interface SmartComponentState {
12
- model: any;
13
- }
14
- export declare class SmartComponent extends React.Component<SmartComponentProps, SmartComponentState> {
15
- private _currentObservingModelId;
16
- private _observationSubscription;
17
- static contextTypes: {
18
- router: PropTypes.Validator<Router>;
19
- };
20
- componentWillReceiveProps(nextProps: SmartComponentProps): void;
21
- componentWillMount(): void;
22
- componentWillUnmount(): void;
23
- _tryObserveModel(modelId: any): void;
24
- _tryDisposeObservationSubscription(): void;
25
- render(): React.CElement<any, React.Component<any, any, any>>;
26
- _getChildProps(): {
27
- model: any;
28
- router: any;
29
- } & {
30
- readonly [x: string]: any;
31
- children?: React.ReactNode | undefined;
32
- };
33
- }
@@ -1,5 +0,0 @@
1
- export declare function removeAll(arr: any, item: any): void;
2
- export declare function isString(value: any): value is string | String;
3
- export declare function format(formatString: any): any;
4
- export declare function startsWith(string: any, searchString: any, position: any): boolean;
5
- export declare function getPropertyNames(object: any): any[];
@@ -1,69 +0,0 @@
1
- import * as React from 'react';
2
- import {DefaultModelAddress, ModelAddress, Router} from 'esp-js';
3
- import {useContext, useCallback, createContext, PropsWithChildren} from 'react';
4
- import {RouterContext} from './routerProvider';
5
-
6
- export type GetModelIdDelegate = () => string;
7
- export const GetModelIdContext = createContext<GetModelIdDelegate>(null);
8
- /**
9
- * Returns a function which will return the ID of the model currently being rendered.
10
- */
11
- export const useGetModelId = () => useContext(GetModelIdContext);
12
-
13
- export type PublishEventDelegate = (modelIdOrModelAddress: string | ModelAddress, eventType: string, event: any) => void;
14
- export const PublishEventContext = createContext<PublishEventDelegate>(null);
15
- /**
16
- * Returns a function which can be used to publish an event.
17
- */
18
- export const usePublishEvent = () => useContext(PublishEventContext);
19
-
20
- export type PublishModelEventDelegate = (eventType: string, event: any) => void;
21
- export const PublishModelEventContext = createContext<PublishModelEventDelegate>(null);
22
- /**
23
- * Returns a function which can be used to publish an event to the current model being rendered.
24
- *
25
- * Effectively, this is a version of usePublishEvent() which closes over the current modelId.
26
- */
27
- export const usePublishModelEvent = () => useContext(PublishModelEventContext);
28
-
29
- export type PublishModelEventWithEntityKeyDelegate = (entityKey: string, eventType: string, event: any) => void;
30
- export const PublishModelEventWithEntityKeyContext = createContext<PublishModelEventWithEntityKeyDelegate>(null);
31
- /**
32
- * Returns a function which can be used to publish an event to the current model being rendered, allows an entityKey to be specified.
33
- *
34
- * Effectively, this is a version of usePublishEvent() which closes over the current modelId.
35
- */
36
- export const usePublishModelEventWithEntityKey = () => useContext(PublishModelEventWithEntityKeyContext);
37
-
38
- export interface EspModelContextProps {
39
- modelId: string;
40
- router: Router;
41
- }
42
-
43
- export const EspModelContext = ({modelId, children, router}: PropsWithChildren<EspModelContextProps>) => {
44
- const getModelId: () => string = useCallback(() => {
45
- return modelId;
46
- }, [router, modelId]);
47
- const publishEvent: PublishEventDelegate = useCallback((modelIdOrModelAddress: string, eventType: string, event: any) => {
48
- router.publishEvent(modelIdOrModelAddress, eventType, event);
49
- }, [router]);
50
- const publishModelEvent: PublishModelEventDelegate = useCallback((eventType: string, event: any) => {
51
- router.publishEvent(modelId, eventType, event);
52
- }, [router, modelId]);
53
- const publishModelEventWithEntityKey: PublishModelEventWithEntityKeyDelegate = useCallback((entityKey: string, eventType: string, event: any) => {
54
- router.publishEvent(new DefaultModelAddress(modelId, entityKey), eventType, event);
55
- }, [router, modelId]);
56
- return (
57
- <RouterContext.Provider value={router}>
58
- <GetModelIdContext.Provider value={getModelId}>
59
- <PublishEventContext.Provider value={publishEvent}>
60
- <PublishModelEventContext.Provider value={publishModelEvent}>
61
- <PublishModelEventWithEntityKeyContext.Provider value={publishModelEventWithEntityKey}>
62
- {children}
63
- </PublishModelEventWithEntityKeyContext.Provider>
64
- </PublishModelEventContext.Provider>
65
- </PublishEventContext.Provider>
66
- </GetModelIdContext.Provider>
67
- </RouterContext.Provider>
68
- );
69
- };
@@ -1,27 +0,0 @@
1
- import {EspMetadata, EspDecoratorUtil} 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
- }
@@ -1,47 +0,0 @@
1
- // notice_start
2
- /*
3
- * Copyright 2015 Dev Shop Limited
4
- *
5
- * Licensed under the Apache License, Version 2.0 (the "License");
6
- * you may not use this file except in compliance with the License.
7
- * You may obtain a copy of the License at
8
- *
9
- * http://www.apache.org/licenses/LICENSE-2.0
10
- *
11
- * Unless required by applicable law or agreed to in writing, software
12
- * distributed under the License is distributed on an "AS IS" BASIS,
13
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
- * See the License for the specific language governing permissions and
15
- * limitations under the License.
16
- */
17
- // notice_end
18
-
19
- import * as React from 'react';
20
- import * as PropTypes from 'prop-types';
21
- import { Router } from 'esp-js';
22
- import {useContext} from 'react';
23
-
24
- export interface RouterProviderProps {
25
- router: Router;
26
- // React 18 Fix:
27
- // The current codebase is React 16, it will work with React 18, but there were changes to the types in React 18.
28
- // The `children` prop was removed from some React types that cause the RouterProvider to fail, this fixes that.
29
- children: any;
30
- }
31
-
32
- export const RouterContext = React.createContext<Router>(null);
33
- export const useRouter = () => useContext(RouterContext);
34
-
35
- export class RouterProvider extends React.Component<RouterProviderProps, any> {
36
- static childContextTypes = {
37
- router: PropTypes.instanceOf(Router).isRequired
38
- };
39
- getChildContext() {
40
- return {
41
- router: this.props.router
42
- };
43
- }
44
- render() {
45
- return (<RouterContext.Provider value={this.props.router}>{this.props.children}</RouterContext.Provider>);
46
- }
47
- }