piral-core 0.15.0-alpha.4332 → 0.15.0-alpha.4345

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';
 
 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);
   });
 });

package/src/actions/define.test.ts

@@ -1,8 +1,8 @@
-import { Atom } from '@dbeining/react-atom';
+import create from 'zustand';
 import { defineAction, defineActions } from './define';
 
 function createMockContainer(initialState = {}) {
-  const state = Atom.of(initialState);
+  const state = create(() => initialState);
   return {
     context: {
       on: jest.fn(),

package/src/actions/portal.test.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { Atom, swap, deref } from '@dbeining/react-atom';
+import create from 'zustand';
 import { showPortal, destroyPortal, hidePortal, updatePortal } from './portal';
 
 describe('Piral-Core portal actions', () => {
@@ -7,19 +7,19 @@ describe('Piral-Core portal actions', () => {
     const children = React.createElement('div');
     const portal: React.ReactPortal = { key: 'test', children: { children }, type: 'div', props: null };
 
-    const state = Atom.of({
+    const state = create(() => ({
       portals: { test: { portal } },
-    });
+    }));
 
     const ctx: any = {
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
     };
 
     destroyPortal(ctx, 'test');
-    const { portals } = deref(ctx.state);
+    const { portals } = ctx.state.getState();
     expect(portals).not.toBeNull();
     expect(portals.test).toBeUndefined();
   });
@@ -29,19 +29,19 @@ describe('Piral-Core portal actions', () => {
     const newPortal: React.ReactPortal = { key: 'test', children: { children }, type: 'div', props: null };
     const portal: React.ReactPortal = { key: 'toast', children: { children }, type: 'div', props: null };
 
-    const state = Atom.of({
+    const state = create(() => ({
       portals: { p1: { portal } },
-    });
+    }));
 
     const ctx: any = {
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
     };
 
     hidePortal(ctx, 'test', newPortal);
-    const { portals } = deref(ctx.state);
+    const { portals } = ctx.state.getState();
     expect(portals).not.toBeNull();
     expect(portals.test).not.toBeNull();
   });
@@ -52,19 +52,19 @@ describe('Piral-Core portal actions', () => {
     const next: React.ReactPortal = { key: 'next', children: { children }, type: 'div', props: null };
     const portal: React.ReactPortal = { key: 'toast', children: { children }, type: 'div', props: null };
 
-    const state = Atom.of({
+    const state = create(() => ({
       portals: { p1: { portal } },
-    });
+    }));
 
     const ctx: any = {
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
     };
 
     updatePortal(ctx, 'test', current, next);
-    const { portals } = deref(ctx.state);
+    const { portals } = ctx.state.getState();
     expect(portals).not.toBeNull();
     expect(portals.test).not.toBeNull();
   });
@@ -74,19 +74,19 @@ describe('Piral-Core portal actions', () => {
     const newPortal: React.ReactPortal = { key: 'test', children: { children }, type: 'div', props: null };
     const portal: React.ReactPortal = { key: 'toast', children: { children }, type: 'div', props: null };
 
-    const state = Atom.of({
+    const state = create(() => ({
       portals: { p1: { portal } },
-    });
+    }));
 
     const ctx: any = {
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
     };
 
     showPortal(ctx, 'test', newPortal);
-    const { portals } = deref(ctx.state);
+    const { portals } = ctx.state.getState();
     expect(portals).not.toBeNull();
     expect(portals.test).not.toBeNull();
   });

package/src/actions/state.test.ts

@@ -1,8 +1,8 @@
-import { Atom, deref } from '@dbeining/react-atom';
+import create from 'zustand';
 import { readState, dispatch } from './state';
 
 function createMockContainer(initialState = {}) {
-  const state = Atom.of(initialState);
+  const state = create(() => initialState);
   return {
     context: {
       on: jest.fn(),
@@ -11,7 +11,7 @@ function createMockContainer(initialState = {}) {
       defineActions() {},
       state,
       read() {
-        return deref(state);
+        return state.getState();
       },
     } as any,
   };

package/src/actions/state.ts

@@ -1,16 +1,15 @@
-import { swap, deref } from '@dbeining/react-atom';
 import { isSame } from '../utils';
 import { GlobalState, GlobalStateContext } from '../types';
 
-function onlyChangedState(oldState: GlobalState, newState: GlobalState) {
-  return isSame(oldState, newState) ? oldState : newState;
-}
-
 export function dispatch(ctx: GlobalStateContext, update: (state: GlobalState) => GlobalState) {
-  swap(ctx.state, oldState => onlyChangedState(oldState, update(oldState)));
+  const oldState = ctx.state.getState();
+  const newState = update(oldState);
+
+  if (!isSame(oldState, newState)) {
+    ctx.state.setState(newState);
+  }
 }
 
 export function readState<S>(ctx: GlobalStateContext, read: (state: GlobalState) => S) {
-  const state = deref(ctx.state);
-  return read(state);
+  return read(ctx.state.getState());
 }

package/src/components/Mediator.test.tsx

@@ -1,18 +1,18 @@
 import * as React from 'react';
+import create from 'zustand';
 import { Mediator } from './Mediator';
-import { Atom, swap, deref } from '@dbeining/react-atom';
 import { mount } from 'enzyme';
 import { StateContext } from '../state';
 import { PiletMetadata } from '../types';
 
 function createMockContainer() {
-  const state = Atom.of({
+  const state = create(() => ({
     app: {
       layout: 'tablet',
       loading: false,
       error: undefined,
     },
-  });
+  }));
   return {
     context: {
       on: jest.fn(),
@@ -20,21 +20,22 @@ function createMockContainer() {
       emit: jest.fn(),
       state,
       dispatch(update) {
-        swap(state, update);
+        state.setState(update(state.getState()));
       },
       readState(select) {
-        return select(deref(state));
+        return select(state.getState());
       },
       initialize(loading, error, modules) {
-        swap(state, (state) => ({
-          ...state,
+        const s = state.getState();
+        state.setState({
+          ...s,
           app: {
-            ...state.app,
+            ...s.app,
             error,
             loading,
           },
           modules,
-        }));
+        } as any);
       },
     } as any,
   };
@@ -54,6 +55,6 @@ describe('Component Mediator', () => {
         <Mediator options={options} />
       </StateContext.Provider>,
     );
-    expect(deref<any>(context.state).app.layout).toEqual('tablet');
+    expect(context.state.getState().app.layout).toEqual('tablet');
   });
 });

package/src/debugger.ts

@@ -1,4 +1,3 @@
-import { addChangeHandler } from '@dbeining/react-atom';
 import { LoadPiletsOptions } from 'piral-base';
 import { installPiralDebug, DebuggerExtensionOptions } from 'piral-debug-utils';
 import { GlobalStateContext } from './types';
@@ -68,7 +67,7 @@ export function integrateDebugger(
         },
       }));
 
-      addChangeHandler(context.state, 'debugging', ({ previous, current }) => {
+      context.state.subscribe((current, previous) => {
         const pilets = current.modules !== previous.modules;
         const pages = current.registry.pages !== previous.registry.pages || current.routes !== previous.routes;
         const extensions = current.registry.extensions !== previous.registry.extensions;

package/src/helpers.test.tsx

@@ -1,7 +1,7 @@
+import create from 'zustand';
 import { createPiletOptions, PiletOptionsConfig } from './helpers';
 import { globalDependencies } from './modules';
 import { PiletMetadata } from 'piral-base';
-import { Atom, swap, deref } from '@dbeining/react-atom';
 
 function createMockApi(meta: PiletMetadata) {
   return {
@@ -13,7 +13,7 @@ function createMockApi(meta: PiletMetadata) {
 }
 
 function createMockContainer() {
-  const state = Atom.of({
+  const state = create(() => ({
     registry: {
       pages: {},
       extensions: {},
@@ -22,7 +22,7 @@ function createMockContainer() {
     routes: {},
     components: {},
     modules: [],
-  });
+  }));
   return {
     context: {
       on: jest.fn(),
@@ -30,19 +30,20 @@ function createMockContainer() {
       emit: jest.fn(),
       state,
       dispatch(cb) {
-        swap(state, cb);
+        state.setState(cb(state.getState()));
       },
       readState(cb) {
-        return cb(deref(state));
+        return cb(state.getState());
       },
       setComponent(name, comp) {
-        swap(state, (s) => ({
+        const s = state.getState();
+        state.setState({
           ...s,
           components: {
             ...s.components,
             [name]: comp,
           },
-        }));
+        });
       },
     } as any,
   };
@@ -85,7 +86,7 @@ describe('Piral-Core helpers module', () => {
     const options = createPiletOptions(optionsConfig);
 
     // Assert
-    expect(options.pilets.length).toEqual(providedPilets.length);
+    expect(options.pilets?.length).toEqual(providedPilets.length);
 
     if (wasUndefined) {
       process.env.DEBUG_PIRAL = undefined;

package/src/hooks/globalState.ts

@@ -1,16 +1,7 @@
 import { useContext } from 'react';
-import { useAtom, deref } from '@dbeining/react-atom';
 import { StateContext } from '../state/stateContext';
 import { GlobalState } from '../types';
 
-const useGlobalAtom = typeof window !== 'undefined' ? useAtom : useDirectAtom;
-
-function useDirectAtom(atom: any, opts: any) {
-  const state = deref(atom);
-  const select = opts && opts.select;
-  return typeof select === 'function' ? select(state) : state;
-}
-
 /**
  * Hook to obtain the global state context, which gives you directly
  * all actions, state, and more of the Piral instance.
@@ -35,6 +26,6 @@ export function useGlobalState(): GlobalState;
 export function useGlobalState<R>(select: (state: GlobalState) => R): R;
 
 export function useGlobalState<R>(select?: (state: GlobalState) => R) {
-  const { state } = useGlobalStateContext();
-  return useGlobalAtom(state, select && { select });
+  const { state: useState } = useGlobalStateContext();
+  return useState(select);
 }

package/src/modules/element-server.test.ts

@@ -2,17 +2,17 @@
  * @jest-environment node
  */
 
-import { Atom, deref } from '@dbeining/react-atom';
+import create from 'zustand';
 import { createListener } from 'piral-base';
 import { createActions } from '../state';
 import { renderElement } from './element';
 
 function createMockContext(): [any, any] {
-  const state = Atom.of({
+  const state: any = create(() => ({
     portals: {
       root: [],
     },
-  });
+  }));
   const context = createActions(state, createListener({}));
   return [context, state];
 }
@@ -24,6 +24,6 @@ describe('Elements Module from SSR', () => {
       addEventListener() {},
     };
     renderElement(context, element, {});
-    expect(deref(state)['portals']['root'].length).toBe(0);
+    expect(state.getState().portals.root.length).toBe(0);
   });
 });

package/src/modules/element.test.ts

@@ -1,4 +1,4 @@
-import { Atom, deref } from '@dbeining/react-atom';
+import create from 'zustand';
 import { createListener } from 'piral-base';
 import { createActions } from '../state';
 import { renderElement } from './element';
@@ -14,9 +14,9 @@ declare global {
 }
 
 function createMockContext(): [any, any] {
-  const state = Atom.of({
+  const state: any = create(() => ({
     portals: {},
-  });
+  }));
   const context = createActions(state, createListener({}));
   return [context, state];
 }
@@ -31,7 +31,7 @@ describe('Elements Module', () => {
     element.dispatchEvent(event);
     document.body.removeChild(element);
     (element as any).connectedCallback();
-    expect(deref(state)['portals']['root'].length).toBe(1);
+    expect(state.getState().portals.root.length).toBe(1);
   });
 
   it('disposing piral-extension web component', () => {
@@ -39,9 +39,9 @@ describe('Elements Module', () => {
     const element = document.createElement('piral-extension');
     document.body.appendChild(element);
     const [dispose] = renderElement(context, element, {});
-    expect(deref(state)['portals']['root'].length).toBe(1);
+    expect(state.getState().portals.root.length).toBe(1);
     dispose();
-    expect(deref(state)['portals']['root'].length).toBe(0);
+    expect(state.getState().portals.root.length).toBe(0);
   });
 
   it('testing setters and getters in piral-extension web component', () => {