rx-tiny-flux 1.0.6 → 1.0.8

package/Readme.md

@@ -89,9 +89,7 @@ Use `createEffect` and the `ofType` operator to build effects.
 
 ```javascript
 // Core library imports
-import { createEffect, ofType } from 'rx-tiny-flux';
-// RxJS operators are imported from the secondary entry point
-import { from, map, concatMap } from 'rx-tiny-flux/rxjs';
+import { createEffect, ofType, from, map, concatMap } from 'rx-tiny-flux';
 
 // Your application's action imports
 import { incrementAsync, incrementSuccess } from './actions';
@@ -116,46 +114,6 @@ const incrementAsyncEffect = createEffect((actions$) =>
 
 ---
 
-## RxJS Operators for ZeppOS
-
-For use in restricted environments like **ZeppOS**, where direct dependencies on `rxjs` are not allowed, `Rx-Tiny-Flux` re-exports a curated set of common RxJS operators and creation functions from its ZeppOS-specific entry point: `rx-tiny-flux/zeppos`. This allows you to build complex effects without needing to manage RxJS imports in your application code.
-
-**Available Exports:**
-
-*   **Creation Functions:** Used to create new Observables.
-    *   `from`: Converts a Promise, an array, or an iterable into an Observable.
-    *   `of`: Emits a variable number of arguments as a sequence and then completes.
-    *   `defer`: Creates an Observable that, on subscription, calls an Observable factory to make a fresh Observable for each new Subscriber.
-
-*   **Constants:**
-    *   `EMPTY`: An Observable that emits no items to the Observer and immediately emits a complete notification. It's useful in effects to stop a stream without dispatching a new action.
-
-*   **Higher-Order Mapping Operators:** Used to manage inner Observables, typically for handling asynchronous operations like API calls.
-    *   `concatMap`: Maps to an inner Observable and processes them sequentially.
-    *   `switchMap`: Maps to an inner Observable but cancels the previous inner subscription if a new outer value arrives.
-    *   `mergeMap`: Maps to an inner Observable and processes them in parallel.
-    *   `exhaustMap`: Maps to an inner Observable but ignores new outer values while the current inner Observable is still active.
-
-*   **Utility Operators:** Used for transformation, filtering, and side effects.
-    *   `map`: Applies a given project function to each value emitted by the source Observable.
-    *   `filter`: Emits only those values from the source Observable that pass a predicate function.
-    *   `tap`: Perform a side effect for every emission on the source Observable, but return an Observable that is identical to the source.
-    *   `delay`: Delays the emission of items from the source Observable by a given timeout.
-    *   `catchError`: Catches errors on the source Observable and returns a new Observable or throws an error.
-
-*   **Utilities:**
-    *   `pipe`: A utility function for composing operators in a readable, left-to-right sequence. While `Observable.pipe()` is the most common usage, having `pipe` available allows for creating reusable operator compositions.
-
-```javascript
-// Instead of managing `rxjs` imports, you can get everything from the `zeppos` entry point:
-import { createEffect, ofType } from 'rx-tiny-flux';
-import { map, from, isApp, propagateAction } from 'rx-tiny-flux/zeppos';
-
-// ... your effect implementation
-```
-
----
-
 ## Selectors
 
 Selectors are pure functions used for obtaining slices of store state. The library provides two factory functions for this:
@@ -240,31 +198,29 @@ This plugin injects `dispatch` and `subscribe` methods into your component's ins
 
 #### How to Use
 
-1.  **Create and configure your store** as usual.
-2.  **Import the `storePlugin`** from `rx-tiny-flux/zeppos`.
-3.  **Register the plugin** globally for `BaseApp` and `BasePage` using the static `.use()` method, passing your store instance.
-4.  **Use `this.dispatch()` and `this.subscribe()`** inside your pages.
+1.  **Create your store** instance in `app.js`.
+2.  **Import the `storePlugin`** from `rx-tiny-flux`.
+3.  **Register the plugin on `BaseApp`**, passing the `store` instance: `BaseApp.use(storePlugin, store)`.
+4.  **Register the same plugin on `BasePage`**, but without the store: `BasePage.use(storePlugin)`. The plugin will automatically find the store from the App.
+5.  **Use `this.dispatch()` and `this.subscribe()`** inside your App and Pages.
 
 Here is a complete example:
 
 ```javascript
 // app.js - Your application's entry point
-import { BaseApp, BasePage } from '@zeppos/zml';
+import { BaseApp } from '@zeppos/zml';
 import { Store } from 'rx-tiny-flux';
-import { storePlugin } from 'rx-tiny-flux/zeppos';
+import { storePlugin } from 'rx-tiny-flux';
 
 // 1. Import your reducers, actions, etc.
 import { counterReducer } from './path/to/reducers';
-import { selectCounterValue } from './path/to/selectors';
-import { increment } from './path/to/actions';
 
 // 2. Create your store instance
 const store = new Store({});
 store.registerReducers(counterReducer);
 
-// 3. Register the plugin globally for App and Pages
+// 3. Register the plugin on BaseApp, providing the store.
 BaseApp.use(storePlugin, store);
-BasePage.use(storePlugin, store);
 
 App(BaseApp({
   // ... your App config
@@ -277,11 +233,14 @@ import { BasePage, ui } from '@zeppos/zml';
 import { selectCounterValue } from '../path/to/selectors';
 import { increment } from './path/to/actions';
 
+// 4. Register the plugin on BasePage, without providing the store. It will be retrieved from the App.
+BasePage.use(storePlugin);
+
 Page(BasePage({
   build() {
     const myText = ui.createWidget(ui.widget.TEXT, { /* ... */ });
 
-    // 4. Use `this.subscribe` to listen to state changes
+    // 5. Use `this.subscribe` to listen to state changes
     this.subscribe(selectCounterValue, (value) => {
       myText.setProperty(ui.prop.TEXT, `Counter: ${value}`);
     });
@@ -313,8 +272,7 @@ Imagine you have a `toast` plugin registered on your `BasePage`. You can create
 
 ```javascript
 // effects/toast.effect.js
-import { createEffect, ofType } from 'rx-tiny-flux';
-import { tap } from 'rx-tiny-flux/rxjs';
+import { createEffect, ofType, tap } from 'rx-tiny-flux';
 import { operationSuccess } from '../actions';
 
 export const showSuccessToastEffect = createEffect(
@@ -346,9 +304,8 @@ These operators filter the action stream based on the execution environment, mak
 **Example: Handling a request between App and Side Service**
 
 ```javascript
-// Import the operators from the zeppos entry point
-import { createEffect, ofType } from 'rx-tiny-flux';
-import { isApp, isSideService } from 'rx-tiny-flux/zeppos';
+// Import all operators from the main entry point
+import { createEffect, ofType, isApp, isSideService } from 'rx-tiny-flux';
 import { fetchData, fetchDataSuccess, fetchDataError } from './actions';
 
 // This effect runs on the App side and requests data from the service
@@ -375,10 +332,8 @@ It works by safely using the `subscribe` method injected into the action's conte
 **Example: Fetching data using a value from the state**
 
 ```javascript
-import { createEffect, ofType } from 'rx-tiny-flux';
-// Import the new operator from the zeppos entry point
-import { withLatestFromStore } from 'rx-tiny-flux/zeppos';
-import { switchMap, map, catchError } from 'rx-tiny-flux/rxjs';
+// Import all operators from the main entry point
+import { createEffect, ofType, withLatestFromStore, switchMap, map, catchError, from, of } from 'rx-tiny-flux';
 import { fetchData, fetchDataSuccess, fetchDataError } from './actions';
 import { selectCurrentUserId } from './selectors';