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
@@ -17,100 +17,33 @@
17
17
  // notice_end
18
18
 
19
19
  import * as espReact from '../src/index';
20
- import {
21
- ViewBinder,
22
- viewBinding,
23
- getEspReactRenderModel,
24
- GetEspReactRenderModelConsts,
25
-
26
- useRouter,
27
- RouterContext,
28
- RouterProvider,
29
-
30
- useGetModelId,
31
- GetModelIdContext,
32
-
33
- PublishEventContext,
34
- usePublishEvent,
35
-
36
- PublishModelEventContext,
37
- usePublishModelEvent,
38
-
39
- PublishModelEventWithEntityKeyContext,
40
- usePublishModelEventWithEntityKey,
41
- } from '../src';
42
20
 
43
21
  describe('index exports', () => {
44
- it('should export RouterProvider', () => {
22
+ it('check exports', () => {
23
+ expect(espReact.viewBinding).toBeDefined();
24
+ expect(espReact.ViewBinder).toBeDefined();
25
+ expect(espReact.DEFAULT_VIEW_KEY).toBeDefined();
26
+ expect(espReact.GetEspPolimerImmutableModelConsts).toBeDefined();
27
+ expect(espReact.getEspPolimerImmutableModel).toBeDefined();
28
+ expect(espReact.createViewForModel).toBeDefined();
29
+ expect(espReact.connect).toBeDefined();
30
+ expect(espReact.ConnectableComponent).toBeDefined();
31
+ expect(espReact.useModelSelector).toBeDefined();
32
+ expect(espReact.modelSelectorOptions).toBeDefined();
45
33
  expect(espReact.RouterProvider).toBeDefined();
46
- expect(RouterProvider).toBeDefined();
47
- });
48
-
49
- it('should export RouterContext', () => {
34
+ expect(espReact.EspRouterContextProvider).toBeDefined();
50
35
  expect(espReact.RouterContext).toBeDefined();
51
- expect(RouterContext).toBeDefined();
52
- });
53
-
54
- it('should export ViewBinder', () => {
55
- expect(espReact.ViewBinder).toBeDefined();
56
- expect(ViewBinder).toBeDefined();
57
- });
58
-
59
- it('should export viewBinding', () => {
60
- expect(espReact.viewBinding).toBeDefined();
61
- expect(viewBinding).toBeDefined();
62
- });
63
-
64
- it('should export getEspReactRenderModel decorator', () => {
65
- expect(espReact.getEspReactRenderModel).toBeDefined();
66
- expect(getEspReactRenderModel).toBeDefined();
67
- });
68
-
69
- it('should export GetEspReactRenderModelConsts', () => {
70
- expect(espReact.GetEspReactRenderModelConsts).toBeDefined();
71
- expect(GetEspReactRenderModelConsts).toBeDefined();
72
- });
73
-
74
- describe('hooks', () => {
75
-
76
- it('should export useRouter and related', () => {
77
- expect(espReact.useRouter).toBeDefined();
78
- expect(useRouter).toBeDefined();
79
-
80
- expect(espReact.RouterContext).toBeDefined();
81
- expect(RouterContext).toBeDefined();
82
- });
83
-
84
- it('should export useGetModelId and related', () => {
85
- expect(espReact.useGetModelId).toBeDefined();
86
- expect(useGetModelId).toBeDefined();
87
-
88
- expect(espReact.GetModelIdContext).toBeDefined();
89
- expect(GetModelIdContext).toBeDefined();
90
- });
91
-
92
- it('should export usePublishEvent and related', () => {
93
- expect(espReact.usePublishEvent).toBeDefined();
94
- expect(usePublishEvent).toBeDefined();
95
-
96
- expect(espReact.PublishEventContext).toBeDefined();
97
- expect(PublishEventContext).toBeDefined();
98
- });
99
-
100
- it('should export usePublishModelEvent and related', () => {
101
- expect(espReact.usePublishModelEvent).toBeDefined();
102
- expect(usePublishModelEvent).toBeDefined();
103
-
104
- expect(espReact.PublishModelEventContext).toBeDefined();
105
- expect(PublishModelEventContext).toBeDefined();
106
- });
107
-
108
- it('should export usePublishModelEventWithEntityKey and related', () => {
109
- expect(espReact.usePublishModelEventWithEntityKey).toBeDefined();
110
- expect(usePublishModelEventWithEntityKey).toBeDefined();
111
-
112
- expect(espReact.PublishModelEventContext).toBeDefined();
113
- expect(PublishModelEventWithEntityKeyContext).toBeDefined();
114
- });
36
+ expect(espReact.useRouter).toBeDefined();
37
+ expect(espReact.PublishEventContext).toBeDefined();
38
+ expect(espReact.usePublishEvent).toBeDefined();
39
+ expect(espReact.useGetModelId).toBeDefined();
40
+ expect(espReact.GetModelIdContext).toBeDefined();
41
+ expect(espReact.useGetModel).toBeDefined();
42
+ expect(espReact.GetModelContext).toBeDefined();
43
+ expect(espReact.PublishModelEventContext).toBeDefined();
44
+ expect(espReact.usePublishModelEvent).toBeDefined();
45
+ expect(espReact.PublishModelEventWithEntityKeyContext).toBeDefined();
46
+ expect(espReact.usePublishModelEventWithEntityKey).toBeDefined();
47
+ expect(espReact.EspModelContextProvider).toBeDefined();
115
48
  });
116
49
  });
@@ -0,0 +1,90 @@
1
+ import {RenderResult} from '@testing-library/react';
2
+ // import for extra asserts
3
+ import '@testing-library/jest-dom';
4
+ import {RouterSpy} from './routerSpy';
5
+ import {TestPropStore} from './useStoreReceivedProps';
6
+
7
+ export type ViewAsserts = {
8
+ valueIs(expected: string): ViewAsserts;
9
+ modelIdIs(expected: string): ViewAsserts
10
+ propIs(propName: string, expected: string): ViewAsserts
11
+ viewNameElementTextIs(viewName: string);
12
+ htmlElementInnerTextIs(elementsTestId: string, expectedText: string): ViewAsserts
13
+ };
14
+
15
+ export const viewAsserts = (renderResult: RenderResult) => {
16
+ return {
17
+ modelIdIs(expected: string) {
18
+ let idElement = renderResult.getByTestId('modelIdDisplay');
19
+ expect(idElement).toHaveTextContent(expected);
20
+ return this;
21
+ },
22
+ valueIs(expected: string) {
23
+ let valueElement = renderResult.getByTestId('valueDisplay');
24
+ expect(valueElement).toHaveTextContent(expected);
25
+ return this;
26
+ },
27
+ propIs(propName: string, expected: string) {
28
+ let span = renderResult.getByTestId('span-with-props-as-attributes');
29
+ let attributeName = `data-${propName}`;
30
+ if (!span.hasAttribute(attributeName)) {
31
+ let error = `Span doesn't have attribute '${attributeName}'. Has ${JSON.stringify(span.attributes)}`;
32
+ fail(error);
33
+ }
34
+ expect(span.getAttribute(attributeName)).toBe(expected);
35
+ return this;
36
+ },
37
+ viewNameElementTextIs(viewName: string) {
38
+ let span = renderResult.getByTestId('view-name');
39
+ expect(span).toHaveTextContent(viewName);
40
+ return this;
41
+ },
42
+ htmlElementInnerTextIs(elementsTestId: string, expectedText: string) {
43
+ let span = renderResult.getByTestId(elementsTestId);
44
+ expect(span).toHaveTextContent(expectedText);
45
+ return this;
46
+ }
47
+
48
+ } as ViewAsserts;
49
+ };
50
+
51
+ export type RouterAsserts = {
52
+ subscriberCountIs(modelId: string, expectedCount: number): RouterAsserts
53
+ };
54
+
55
+ export const routerAsserts = (routerSpy: RouterSpy) => {
56
+ return {
57
+ subscriberCountIs(modelId: string, expectedCount: number) {
58
+ if (expectedCount === 0) {
59
+ let modelNotSubscribed = routerSpy.getSubscriberCount(modelId) === undefined || routerSpy.getSubscriberCount(modelId) === 0;
60
+ expect(modelNotSubscribed).toBeTruthy();
61
+ } else {
62
+ expect(routerSpy.getSubscriberCount(modelId)).toEqual(expectedCount);
63
+ }
64
+ return this;
65
+ },
66
+ } as RouterAsserts;
67
+ };
68
+
69
+ export type PropAsserts = {
70
+ receivedPropCountIs(expectedCount: number): PropAsserts;
71
+ propAtIndex(index: number, asserter: (props) => void): PropAsserts
72
+ propAtIndexHasModelId(index: number, expectedModelId: string): PropAsserts
73
+ };
74
+
75
+ export const propAsserts = (testPropStore: TestPropStore) => {
76
+ return {
77
+ receivedPropCountIs(expectedCount: number) {
78
+ expect(testPropStore.receivedProps.length).toEqual(expectedCount);
79
+ return this;
80
+ },
81
+ propAtIndex(index: number, asserter: (props) => void): PropAsserts {
82
+ asserter(testPropStore.receivedProps[index]);
83
+ return this;
84
+ },
85
+ propAtIndexHasModelId(index: number, expectedModelId: string): PropAsserts {
86
+ expect(testPropStore.receivedProps[index].modelId).toBe(expectedModelId);
87
+ return this;
88
+ },
89
+ } as PropAsserts;
90
+ };
@@ -0,0 +1,100 @@
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, ReactElement} from 'react';
8
+ import {TestPropStore, TestPropStoreContext} from './useStoreReceivedProps';
9
+
10
+ export type TestApi = {
11
+ router: RouterSpy;
12
+ propStore: TestPropStore;
13
+ asserts: {
14
+ router: RouterAsserts,
15
+ view: ViewAsserts,
16
+ props: PropAsserts,
17
+ };
18
+ setupModel<TModel>(modelId: string, model: TModel): TModel;
19
+ setupTestModel(modelId: string): TestModel;
20
+ setupModelAndRender(modelId: string, Component: React.ComponentType): TestApi;
21
+ doRender(Component: React.ComponentType, modelIdForContext?: string): TestApi
22
+ doRender(Component: React.JSX.Element, modelIdForContext?: string): TestApi
23
+ doReRender(Component: React.ComponentType, modelIdForContext?: string, nextProps?: any): TestApi;
24
+ doReRender(Component: React.JSX.Element, modelIdForContext?: string, nextProps?: any): TestApi;
25
+ };
26
+
27
+ export const testApi = ()=> {
28
+ let router: RouterSpy = new RouterSpy();
29
+ let renderResult: RenderResult;
30
+ let propStore = new TestPropStore();
31
+ return {
32
+ router,
33
+ propStore,
34
+ asserts: {
35
+ get router() {
36
+ return routerAsserts(router);
37
+ },
38
+ get view() {
39
+ return viewAsserts(renderResult);
40
+ },
41
+ get props() {
42
+ return propAsserts(propStore);
43
+ }
44
+ },
45
+ setupModelAndRender(modelId: string, view: React.ComponentType) {
46
+ this.setupTestModel(modelId);
47
+ this.doRender(view, modelId);
48
+ return this;
49
+ },
50
+ setupModel<TModel>(modelId: string, model: TModel): TModel {
51
+ router.addModel(modelId, model);
52
+ router.observeEventsOn(modelId, model);
53
+ return model;
54
+ },
55
+ setupTestModel(modelId: string): TestModel {
56
+ const testModel = new TestModel(modelId);
57
+ router.addModel(modelId, testModel);
58
+ router.observeEventsOn(modelId, testModel);
59
+ return testModel;
60
+ },
61
+ doRender(ComponentOrElement: any, modelIdForContext?: string, nextProps?: any) {
62
+ let element: React.JSX.Element;
63
+ if (isValidElement(ComponentOrElement)) {
64
+ element = ComponentOrElement;
65
+ } else {
66
+ element = <ComponentOrElement />;
67
+ }
68
+ let elementWithProps = React.cloneElement(element, nextProps);
69
+ renderResult = render((
70
+ <TestPropStoreContext.Provider value={propStore}>
71
+ <EspRouterContextProvider router={router}>
72
+ <EspModelContextProvider modelId={modelIdForContext}>
73
+ {elementWithProps},
74
+ </EspModelContextProvider>
75
+ </EspRouterContextProvider>
76
+ </TestPropStoreContext.Provider>
77
+ ));
78
+ return this;
79
+ },
80
+ doReRender(ComponentOrElement: any, modelIdForContext?: string, nextProps?: any) {
81
+ let element: React.JSX.Element;
82
+ if (isValidElement(ComponentOrElement)) {
83
+ element = ComponentOrElement;
84
+ } else {
85
+ element = <ComponentOrElement />;
86
+ }
87
+ let elementWithProps = React.cloneElement(element, nextProps);
88
+ renderResult.rerender((
89
+ <TestPropStoreContext.Provider value={propStore}>
90
+ <EspRouterContextProvider router={router}>
91
+ <EspModelContextProvider modelId={modelIdForContext}>
92
+ {elementWithProps},
93
+ </EspModelContextProvider>
94
+ </EspRouterContextProvider>
95
+ </TestPropStoreContext.Provider>
96
+ ));
97
+ return this;
98
+ }
99
+ } as TestApi;
100
+ };
@@ -0,0 +1,44 @@
1
+ import {EventContext, observeEvent} from 'esp-js';
2
+ import {GetEspPolimerImmutableModelConsts} from '../../src';
3
+
4
+ export type TestModelImmutableState = { value: string, modelId: string, entityKey: string };
5
+
6
+ export class TestModel {
7
+
8
+ private _internalState: TestModelImmutableState;
9
+
10
+ constructor(modelId: string) {
11
+ this._internalState = {
12
+ value: 'initial-value',
13
+ entityKey: '',
14
+ modelId: modelId,
15
+ };
16
+ }
17
+
18
+ public get state(): TestModelImmutableState {
19
+ return this._internalState;
20
+ }
21
+
22
+ @observeEvent('test-event')
23
+ _onTestEvent(ev: string) {
24
+ // mimic some immutable logic that would be provided by a lib such as immer in a real app.
25
+ this._internalState = {
26
+ ...this._internalState,
27
+ value: ev
28
+ };
29
+ }
30
+
31
+ @observeEvent('test-event-with-entity-key')
32
+ _onTestEventWithEntityKey(ev: string, eventContext: EventContext) {
33
+ // mimic some immutable logic that would be provided by a lib such as immer in a real app.
34
+ this._internalState = {
35
+ ...this._internalState,
36
+ entityKey: eventContext.entityKey,
37
+ value: ev
38
+ };
39
+ }
40
+
41
+ [GetEspPolimerImmutableModelConsts.HandlerFunctionName]: () => TestModelImmutableState = () => {
42
+ return this._internalState;
43
+ };
44
+ }
@@ -0,0 +1,14 @@
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
+ getLastProps(): any {
12
+ return this.receivedProps[this.receivedProps.length -1];
13
+ }
14
+ }
@@ -0,0 +1,31 @@
1
+ import {useTestPropStore} from './useStoreReceivedProps';
2
+ import * as React from 'react';
3
+
4
+ export const viewFactory = (name: string) => {
5
+ return (props: { modelId: string; value: string, [key: string]: any }) => {
6
+ let testPropStore = useTestPropStore();
7
+ testPropStore.pushProps(props);
8
+ return (
9
+ <>
10
+ <span data-testid='view-name'>{name}</span>
11
+ <ViewMetadata modelId={props.modelId} modelValue={props.value} {...props}/>
12
+ </>
13
+ );
14
+ };
15
+ };
16
+
17
+ export type ViewMetadataProps = {
18
+ modelId: string,
19
+ modelValue: string
20
+ [key: string]: string; // ...rest props
21
+ };
22
+
23
+ export const ViewMetadata = (props: ViewMetadataProps) => {
24
+ const { modelId, modelValue, ...rest} = props;
25
+ return (
26
+ <div>
27
+ <span data-testid='modelIdDisplay'>{modelId}</span>
28
+ <span data-testid='valueDisplay'>{modelValue}</span>
29
+ </div>
30
+ );
31
+ };