piral-core 1.0.0-pre.2296 → 1.0.1-beta.5640

package/src/actions/app.test.ts

@@ -1,96 +1,166 @@
+import create from 'zustand';
+import { render } from '@testing-library/react';
 import { createElement } from 'react';
-import { Atom, deref } from '@dbeining/react-atom';
-import { changeLayout, includeProvider } from './app';
-import { createListener } from '../utils';
+import { createListener, Pilet } from 'piral-base';
+import {
+  includeProvider,
+  initialize,
+  injectPilet,
+  removePilet,
+  setComponent,
+  setErrorComponent,
+  setRoute,
+} from './app';
 import { createActions } from '../state';
-import { mount } from 'enzyme';
+import { RootListener } from '../RootListener';
+
+const pilet: Pilet = {
+  name: 'my-pilet',
+  version: '1.0.0',
+  link: undefined,
+  custom: undefined,
+};
 
 describe('App Actions Module', () => {
-  it('changeLayout changes the current layout', () => {
-    const state = Atom.of({
-      foo: 5,
-      app: {
-        layout: 'tablet',
-      },
-    });
+  it('initialize initializes state data', () => {
+    const state: any = create(() => ({
+      app: {},
+    }));
     const ctx = createActions(state, createListener({}));
-    changeLayout(ctx, 'mobile');
-    expect(deref(state)).toEqual({
-      foo: 5,
-      app: {
-        layout: 'mobile',
-      },
+    const modules: any = ['pilet 1', 'pilet 2', 'pilet 3'];
+    initialize(ctx, false, undefined, modules);
+    expect(state.getState()).toEqual({
+      app: { error: undefined, loading: false },
+      modules: ['pilet 1', 'pilet 2', 'pilet 3'],
     });
   });
 
+  it('removePilet removes pilet', () => {
+    const state: any = create(() => ({
+      app: {},
+      modules: [pilet],
+      registry: { 'my-pilet': pilet },
+    }));
+    const ctx = createActions(state, createListener({}));
+    removePilet(ctx, 'my-pilet');
+    expect(state.getState()).toEqual({ app: {}, modules: [], registry: { 'my-pilet': pilet } });
+  });
+
+  it('injectPilet injects pilet', () => {
+    const pilet2: Pilet = {
+      name: 'my-pilet2',
+      version: '1.0.0',
+      link: undefined,
+      custom: undefined,
+    };
+    const state: any = create(() => ({
+      app: {},
+      modules: [pilet2],
+      registry: { pilet2 },
+    }));
+    const ctx = createActions(state, createListener({}));
+    injectPilet(ctx, pilet);
+    expect(state.getState()).toEqual({ app: {}, modules: [pilet2, pilet], registry: { pilet2 } });
+  });
+
+  it('setComponent set component', () => {
+    const state: any = create(() => ({
+      components: {},
+    }));
+    const ctx = createActions(state, createListener({}));
+    const node = RootListener;
+    setComponent(ctx, 'ComponentName', node);
+    expect(state.getState()).toEqual({ components: { ComponentName: RootListener } });
+  });
+
+  it('setErrorComponent set error component', () => {
+    const state: any = create(() => ({
+      errorComponents: {},
+    }));
+    const ctx = createActions(state, createListener({}));
+    const node = RootListener;
+    setErrorComponent(ctx, 'ComponentName', node);
+    expect(state.getState()).toEqual({ errorComponents: { ComponentName: RootListener } });
+  });
+
+  it('setRoute sets route', () => {
+    const state: any = create(() => ({
+      routes: {},
+    }));
+    const ctx = createActions(state, createListener({}));
+    const node = RootListener;
+    setRoute(ctx, './dist', RootListener);
+    expect(state.getState()).toEqual({ routes: { './dist': RootListener } });
+  });
+
   it('allows using includeProvider once', () => {
-    const state = Atom.of({
+    const state: any = create(() => ({
       provider: undefined,
-    });
+    }));
     const Provider = (props) => createElement('div', props);
     const ctx = createActions(state, createListener({}));
     includeProvider(ctx, createElement(Provider));
 
-    const NewProvider = deref(state).provider;
+    const NewProvider = state.getState().provider;
     expect(NewProvider).not.toBeUndefined();
 
-    const node = mount(createElement(NewProvider, undefined, 'Some text'));
-    expect(node.find('div').length).toBe(1);
-    expect(node.text()).toBe('Some text');
+    const node = render(createElement(NewProvider, undefined, 'Some text'));
+    expect(node.container.querySelectorAll('div').length).toBe(1);
+    expect(node.container.textContent).toBe('Some text');
   });
 
   it('allows using includeProvider twice', () => {
-    const state = Atom.of({
+    const state: any = create(() => ({
       provider: undefined,
-    });
+    }));
     const Provider1 = (props) => createElement('i', props);
     const Provider2 = (props) => createElement('b', props);
     const ctx = createActions(state, createListener({}));
     includeProvider(ctx, createElement(Provider1));
     includeProvider(ctx, createElement(Provider2));
 
-    const NewProvider = deref(state).provider;
+    const NewProvider = state.getState().provider;
     expect(NewProvider).not.toBeUndefined();
 
-    const node = mount(createElement(NewProvider, undefined, 'Some text'));
-    expect(node.find('b').length).toBe(1);
-    expect(node.find('i').length).toBe(1);
-    expect(node.text()).toBe('Some text');
+    const node = render(createElement(NewProvider, undefined, 'Some text'));
+    expect(node.container.querySelectorAll('b').length).toBe(1);
+    expect(node.container.querySelectorAll('i').length).toBe(1);
+    expect(node.container.textContent).toBe('Some text');
   });
 
   it('allows using includeProvider with props', () => {
-    const state = Atom.of({
+    const state: any = create(() => ({
       provider: undefined,
-    });
+    }));
     const Provider = (props) => createElement('i', props, props.text, props.children);
     const ctx = createActions(state, createListener({}));
     includeProvider(ctx, createElement(Provider, { text: 'Icecream' }));
 
-    const NewProvider = deref(state).provider;
+    const NewProvider = state.getState().provider;
     expect(NewProvider).not.toBeUndefined();
 
-    const node = mount(createElement(NewProvider, undefined, 'Some text'));
-    expect(node.find('b').length).toBe(0);
-    expect(node.find('i').length).toBe(1);
-    expect(node.text()).toBe('IcecreamSome text');
+    const node = render(createElement(NewProvider, undefined, 'Some text'));
+    expect(node.container.querySelectorAll('b').length).toBe(0);
+    expect(node.container.querySelectorAll('i').length).toBe(1);
+    expect(node.container.textContent).toBe('IcecreamSome text');
   });
 
   it('allows multiple includeProvider with props', () => {
-    const state = Atom.of({
+    const state: any = create(() => ({
       provider: undefined,
-    });
+    }));
     const Provider1 = (props) => createElement('i', props, props.text, props.children);
     const Provider2 = (props) => createElement('b', props, props.text, props.children);
     const ctx = createActions(state, createListener({}));
     includeProvider(ctx, createElement(Provider1, { text: 'Icecream' }));
     includeProvider(ctx, createElement(Provider2, { text: 'Chocolate' }));
 
-    const NewProvider = deref(state).provider;
+    const NewProvider = state.getState().provider;
     expect(NewProvider).not.toBeUndefined();
 
-    const node = mount(createElement(NewProvider, undefined, 'Some text'));
-    expect(node.find('b').length).toBe(1);
-    expect(node.find('i').length).toBe(1);
-    expect(node.text()).toBe('IcecreamChocolateSome text');
+    const node = render(createElement(NewProvider, undefined, 'Some text'));
+    expect(node.container.querySelectorAll('b').length).toBe(1);
+    expect(node.container.querySelectorAll('i').length).toBe(1);
+    expect(node.container.textContent).toBe('IcecreamChocolateSome text');
   });
 });

package/src/actions/app.ts

@@ -1,23 +1,17 @@
-import { ComponentType, cloneElement, createElement } from 'react';
+import { ComponentType } from 'react';
 import { RouteComponentProps } from 'react-router';
-import { withKey, replaceOrAddItem, removeNested } from '../utils';
+import { runPilet } from 'piral-base';
+import { withKey, replaceOrAddItem, removeNested, withProvider, withRoute, noop } from '../utils';
 import {
-  LayoutType,
   ComponentsState,
   ErrorComponentsState,
   BaseRegistration,
   RegistryState,
   GlobalStateContext,
   Pilet,
+  PiletEntry,
 } from '../types';
 
-export function changeLayout(ctx: GlobalStateContext, current: LayoutType) {
-  ctx.dispatch((state) => ({
-    ...state,
-    app: withKey(state.app, 'layout', current),
-  }));
-}
-
 export function initialize(ctx: GlobalStateContext, loading: boolean, error: Error | undefined, modules: Array<Pilet>) {
   ctx.dispatch((state) => ({
     ...state,
@@ -30,16 +24,40 @@ export function initialize(ctx: GlobalStateContext, loading: boolean, error: Err
   }));
 }
 
-export function injectPilet(ctx: GlobalStateContext, pilet: Pilet) {
+export function addPilet(ctx: GlobalStateContext, meta: PiletEntry): Promise<void> {
+  return ctx.options
+    .loadPilet(meta)
+    .then((pilet) => ctx.injectPilet(pilet))
+    .then((pilet) => runPilet(ctx.options.createApi, pilet, ctx.options.hooks))
+    .then(noop);
+}
+
+export function removePilet(ctx: GlobalStateContext, name: string): Promise<void> {
+  ctx.dispatch((state) => ({
+    ...state,
+    modules: state.modules.filter((m) => m.name !== name),
+    registry: removeNested<RegistryState, BaseRegistration>(state.registry, (m) => m.pilet === name),
+  }));
+
+  ctx.emit('unload-pilet', {
+    name,
+  });
+
+  return Promise.resolve();
+}
+
+export function injectPilet(ctx: GlobalStateContext, pilet: Pilet): Pilet {
   ctx.dispatch((state) => ({
     ...state,
     modules: replaceOrAddItem(state.modules, pilet, (m) => m.name === pilet.name),
     registry: removeNested<RegistryState, BaseRegistration>(state.registry, (m) => m.pilet === pilet.name),
   }));
-  
+
   ctx.emit('unload-pilet', {
     name: pilet.name,
   });
+
+  return pilet;
 }
 
 export function setComponent<TKey extends keyof ComponentsState>(
@@ -64,22 +82,14 @@ export function setErrorComponent<TKey extends keyof ErrorComponentsState>(
   }));
 }
 
-export function setRoute<T = {}>(
+export function setRoute<T extends { [K in keyof T]?: string } = {}>(
   ctx: GlobalStateContext,
   path: string,
   component: ComponentType<RouteComponentProps<T>>,
 ) {
-  ctx.dispatch((state) => ({
-    ...state,
-    routes: withKey(state.routes, path, component),
-  }));
+  ctx.dispatch(withRoute(path, component));
 }
 
 export function includeProvider(ctx: GlobalStateContext, provider: JSX.Element) {
-  const wrapper: React.FC = (props) => cloneElement(provider, props);
-
-  ctx.dispatch((state) => ({
-    ...state,
-    provider: !state.provider ? wrapper : (props) => createElement(state.provider, undefined, wrapper(props)),
-  }));
+  ctx.dispatch(withProvider(provider));
 }

package/src/actions/components.test.ts

@@ -1,20 +1,20 @@
-import { Atom, deref } from '@dbeining/react-atom';
+import create from 'zustand';
+import { createListener } from 'piral-base';
 import { registerExtension, registerPage, unregisterExtension, unregisterPage } from './components';
 import { createActions } from '../state';
-import { createListener } from '../utils';
 
 describe('Components Actions Module', () => {
   it('registerExtension and unregisterExtension', () => {
-    const state = Atom.of({
+    const state: any = create(() => ({
       foo: 5,
       registry: {
         foo: 5,
         extensions: {},
       },
-    });
+    }));
     const ctx = createActions(state, createListener({}));
     registerExtension(ctx, 'foo', 10 as any);
-    expect(deref(state)).toEqual({
+    expect(state.getState()).toEqual({
       foo: 5,
       registry: {
         foo: 5,
@@ -23,8 +23,8 @@ describe('Components Actions Module', () => {
         },
       },
     });
-    unregisterExtension(ctx, 'foo');
-    expect(deref(state)).toEqual({
+    unregisterExtension(ctx, 'foo', undefined);
+    expect(state.getState()).toEqual({
       foo: 5,
       registry: {
         foo: 5,
@@ -36,16 +36,16 @@ describe('Components Actions Module', () => {
   });
 
   it('registerPage and unregisterPage', () => {
-    const state = Atom.of({
+    const state: any = create(() => ({
       foo: 5,
       registry: {
         foo: 5,
         pages: {},
       },
-    });
+    }));
     const ctx = createActions(state, createListener({}));
     registerPage(ctx, 'foo', 10 as any);
-    expect(deref(state)).toEqual({
+    expect(state.getState()).toEqual({
       foo: 5,
       registry: {
         foo: 5,
@@ -55,7 +55,7 @@ describe('Components Actions Module', () => {
       },
     });
     unregisterPage(ctx, 'foo');
-    expect(deref(state)).toEqual({
+    expect(state.getState()).toEqual({
       foo: 5,
       registry: {
         foo: 5,

package/src/actions/components.ts

@@ -1,46 +1,18 @@
-import { appendItem, excludeOn, withKey, withoutKey } from '../utils';
+import { withExtension, withoutExtension, withoutPage, withPage } from '../utils';
 import { PageRegistration, ExtensionRegistration, GlobalStateContext } from '../types';
 
 export function registerPage(ctx: GlobalStateContext, name: string, value: PageRegistration) {
-  ctx.dispatch((state) => ({
-    ...state,
-    registry: {
-      ...state.registry,
-      pages: withKey(state.registry.pages, name, value),
-    },
-  }));
+  ctx.dispatch(withPage(name, value));
 }
 
 export function unregisterPage(ctx: GlobalStateContext, name: string) {
-  ctx.dispatch((state) => ({
-    ...state,
-    registry: {
-      ...state.registry,
-      pages: withoutKey(state.registry.pages, name),
-    },
-  }));
+  ctx.dispatch(withoutPage(name));
 }
 
 export function registerExtension(ctx: GlobalStateContext, name: string, value: ExtensionRegistration) {
-  ctx.dispatch((state) => ({
-    ...state,
-    registry: {
-      ...state.registry,
-      extensions: withKey(state.registry.extensions, name, appendItem(state.registry.extensions[name], value)),
-    },
-  }));
+  ctx.dispatch(withExtension(name, value));
 }
 
 export function unregisterExtension(ctx: GlobalStateContext, name: string, reference: any) {
-  ctx.dispatch((state) => ({
-    ...state,
-    registry: {
-      ...state.registry,
-      extensions: withKey(
-        state.registry.extensions,
-        name,
-        excludeOn(state.registry.extensions[name], (m) => m.reference === reference),
-      ),
-    },
-  }));
+  ctx.dispatch(withoutExtension(name, reference));
 }

package/src/actions/data.test.ts

@@ -1,22 +1,22 @@
-import { Atom, deref, swap } from '@dbeining/react-atom';
+import create from 'zustand';
+import { createListener } from 'piral-base';
 import { readDataItem, readDataValue, resetData, tryWriteDataItem, writeDataItem } from './data';
-import { createListener } from '../utils';
 
 describe('Data Actions Module', () => {
   it('readDataItem reads the current item', () => {
-    const state = Atom.of({
+    const state = create(() => ({
       foo: 5,
       data: {
         foo: 10,
       },
-    });
+    }));
     const ctx: any = {
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
       readState(select) {
-        return select(deref(state));
+        return select(state.getState());
       },
     };
     const value = readDataItem(ctx, 'foo');
@@ -24,21 +24,21 @@ describe('Data Actions Module', () => {
   });
 
   it('readDataValue reads the current value', () => {
-    const state = Atom.of({
+    const state = create(() => ({
       foo: 5,
       data: {
         foo: {
           value: 15,
         },
       },
-    });
+    }));
     const ctx: any = {
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
       readState(select) {
-        return select(deref(state));
+        return select(state.getState());
       },
     };
     const value = readDataValue(ctx, 'foo');
@@ -46,48 +46,48 @@ describe('Data Actions Module', () => {
   });
 
   it('resetData clears all items', () => {
-    const state = Atom.of({
+    const state = create(() => ({
       foo: 5,
       data: {
         foo: 10,
         bar: [5],
       },
-    });
+    }));
     const ctx: any = {
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
       readState(select) {
-        return select(deref(state));
+        return select(state.getState());
       },
     };
     resetData(ctx);
-    expect(deref(state)).toEqual({
+    expect(state.getState()).toEqual({
       foo: 5,
       data: {},
     });
   });
 
   it('writeDataItem adds a new data item', () => {
-    const state = Atom.of({
+    const state = create(() => ({
       foo: 5,
       data: {
         foo: 10,
         bar: [5],
       },
-    });
+    }));
     const ctx: any = Object.assign(createListener(undefined), {
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
       readState(select) {
-        return select(deref(state));
+        return select(state.getState());
       },
     });
-    writeDataItem(ctx, 'fi', 0);
-    expect(deref(state)).toEqual({
+    writeDataItem(ctx, 'fi', 0, undefined, undefined, undefined);
+    expect(state.getState()).toEqual({
       foo: 5,
       data: {
         foo: 10,
@@ -103,24 +103,24 @@ describe('Data Actions Module', () => {
   });
 
   it('writeDataItem overwrites an existing data item', () => {
-    const state = Atom.of({
+    const state = create(() => ({
       foo: 5,
       data: {
         foo: 10,
         bar: [5],
       },
-    });
+    }));
     const ctx: any = Object.assign(createListener(undefined), {
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
       readState(select) {
-        return select(deref(state));
+        return select(state.getState());
       },
     });
-    writeDataItem(ctx, 'bar', 0);
-    expect(deref(state)).toEqual({
+    writeDataItem(ctx, 'bar', 0, undefined, undefined, undefined);
+    expect(state.getState()).toEqual({
       foo: 5,
       data: {
         foo: 10,
@@ -135,24 +135,24 @@ describe('Data Actions Module', () => {
   });
 
   it('writeDataItem removes an existing data item', () => {
-    const state = Atom.of({
+    const state = create(() => ({
       foo: 5,
       data: {
         foo: 10,
         bar: [5],
       },
-    });
+    }));
     const ctx: any = Object.assign(createListener(undefined), {
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
       readState(select) {
-        return select(deref(state));
+        return select(state.getState());
       },
     });
-    writeDataItem(ctx, 'bar', null);
-    expect(deref(state)).toEqual({
+    writeDataItem(ctx, 'bar', null, undefined, undefined, undefined);
+    expect(state.getState()).toEqual({
       foo: 5,
       data: {
         foo: 10,
@@ -161,27 +161,27 @@ describe('Data Actions Module', () => {
   });
 
   it('tryWriteDataItem can write new item', () => {
-    const state = Atom.of({
+    const state = create(() => ({
       foo: 5,
       data: {
         foo: 10,
       },
-    });
+    }));
     const ctx: any = Object.assign(createListener(undefined), {
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
       readState(select) {
-        return select(deref(state));
+        return select(state.getState());
       },
     });
-    const success = tryWriteDataItem(ctx, 'bar', 10, 'me');
+    const success = tryWriteDataItem(ctx, 'bar', 10, 'me', undefined, undefined);
     expect(success).toBe(true);
   });
 
   it('tryWriteDataItem can overwrite item if owner', () => {
-    const state = Atom.of({
+    const state = create(() => ({
       foo: 5,
       data: {
         foo: 10,
@@ -190,23 +190,23 @@ describe('Data Actions Module', () => {
           value: 5,
         },
       },
-    });
+    }));
     const ctx: any = Object.assign(createListener(undefined), {
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
       readState(select) {
-        return select(deref(state));
+        return select(state.getState());
       },
     });
-    const success = tryWriteDataItem(ctx, 'bar', 10, 'me');
+    const success = tryWriteDataItem(ctx, 'bar', 10, 'me', undefined, undefined);
     expect(success).toBe(true);
-    expect(deref(state).data.bar.value).toBe(10);
+    expect(state.getState().data.bar.value).toBe(10);
   });
 
   it('tryWriteDataItem can not overwrite item if not owner', () => {
-    const state = Atom.of({
+    const state = create(() => ({
       foo: 5,
       data: {
         foo: 10,
@@ -215,18 +215,18 @@ describe('Data Actions Module', () => {
           value: 5,
         },
       },
-    });
+    }));
     const ctx: any = Object.assign(createListener(undefined), {
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
       readState(select) {
-        return select(deref(state));
+        return select(state.getState());
       },
     });
-    const success = tryWriteDataItem(ctx, 'bar', 10, 'me');
+    const success = tryWriteDataItem(ctx, 'bar', 10, 'me', undefined, undefined);
     expect(success).toBe(false);
-    expect(deref(state).data.bar.value).toBe(5);
+    expect(state.getState().data.bar.value).toBe(5);
   });
 });