flinker 2.0.3 → 2.0.4

package/README.md

@@ -1,7 +1,210 @@
-# Install
-```cli
+## Intro
+__Flinker__ is a functional reactive programming library. __Flinker__ is not limited to user interfaces. It also can be adapted to React.js (e.g. [flinker-react](https://github.com/Dittner/Flinker-React)) or your own frontend framework (e.g. [flinker-dom](https://github.com/Dittner/FlinkerDom)).
+
+## RXPublisher, RXPipeline, RXOperator and RXSubscriber
+Four key concepts: publisher, pipeline, operator and subscriber. A publisher provides data when available and upon request. To subscribe to changes, the publisher provides the `pipe()` method, which creates a pipeline.
+
+RXPipeline is a queue of operators (RXOperator) to control the flow of data. Operators are a convenient name for a number of pre-built functions such as: map, flatMap, filter, debounce, etc. 
+
+Subscribers are responsible for accepting the data (and possible errors) provided by a publisher. Subscribers are joined to the end of a pipeline.
+
+A publisher is generating and sending data, operators are reacting to that data and potentially changing it, and subscribers accepting result. RXPublisher cannot be used directly, its subclasses must be used instead:
+
++ RXObservableValue
++ RXObservableEntity
++ RXSubject
++ RXEmitter
++ RXOperation
++ RXBuffer
++ RXCombine
++ RXJustComplete
++ RXDelayedComplete
++ RXJustError
++ RXDelayedError
++ RXFrom
++ RXQueue
+
+## RXObservableValue
+It does not dispatch errors and completion, has a default value.
+
+```ts
+let buffer = ''
+const rx = new RXObservableValue(1) // extends RXPublisher
+rx.pipe() // creates RXPipeline
+  .onReceive(v => buffer += v) // creates RXSubscriber
+  .subscribe() // returns unsubscribe function: () => void
+
+expect(buffer).toBe('1') //true
+
+rx.value = 2
+rx.value = 3
+
+expect(buffer).toBe('123') //true
+```
+
+## RXOperation
+It dispatches value or error and immediately after that completion.
+
+```ts
+const op = new RXOperation<number, void>()
+let buffer1 = ''
+let buffer2 = ''
+
+op.pipe()
+  .onReceive(v => (buffer1 += v + ''))
+  .onError(() => (buffer1 += 'e'))
+  .onComplete(() => (buffer1 += 'c'))
+  .subscribe()
+
+op.fail()
+op.fail() // no effect
+op.success(10) // no effect
+op.success(20) // no effect
+
+op.pipe()
+  .onReceive(value => (buffer2 += value + ''))
+  .onError(() => (buffer2 += 'e'))
+  .onComplete(() => (buffer2 += 'c'))
+  .subscribe()
+
+expect(buffer1).toBe('ec') // true
+expect(buffer2).toBe('ec') // true
+```
+
+## RXSubject
+It has a default value. If you do not want to have a default value use RXEmitter instead.
+
+```ts
+const rx = new RXSubject(0)
+let buffer = -1
+
+rx.pipe()
+  .onReceive(v => buffer = v)
+  .subscribe()
+
+expect(buffer).toBe(0) // true
+
+rx.send(1)
+expect(buffer).toBe(1) // true
+
+rx.sendComplete()
+expect(buffer).toBe(1) // true
+
+rx.send(2) // no effect after complete
+expect(buffer).toBe(1) // true
+```
+
+## Map Operator
+```ts
+const rx = new RXEmitter<string, never>()
+let buffer = ''
+
+rx.pipe()
+  .map(v => v.toUpperCase())
+  .map(v => v ? v : '-')
+  .onReceive(v => buffer += v)
+  .subscribe()
+
+expect(buffer).toBe('') // true
+
+rx.send('a')
+rx.send('b')
+rx.send('')
+rx.send('c')
+expect(buffer).toBe('AB-C') // true
+```
+
+## Filter Operator
+```ts
+const rx = new RXSubject(0)
+let buffer = ''
+
+rx.pipe()
+  .removeDuplicates()
+  .filter(v => v % 2 === 0)
+  .map(v => v + '')
+  .filter(v => v.length === 1)
+  .onReceive(v => buffer += v)
+  .subscribe()
+
+rx.send(0)
+rx.send(0)
+rx.send(1)
+rx.send(1)
+rx.send(2)
+rx.send(3)
+rx.send(4)
+rx.send(5)
+rx.send(6)
+rx.send(7)
+rx.send(8)
+rx.send(9)
+rx.send(10)
+rx.send(11)
+rx.send(12)
+
+expect(buffer).toBe('02468') // true
+```
+
+## SkipNullable Operator
+```ts
+const rx = new RXSubject<number | undefined | null, never>(0)
+let buffer = ''
+
+rx.pipe()
+  .removeDuplicates()
+  .skipNullable()
+  .map(v => v + '')
+  .onReceive(v => buffer += v)
+  .subscribe()
+
+rx.send(0)
+rx.send(1)
+rx.send(undefined)
+rx.send(2)
+rx.send(2)
+rx.send(3)
+rx.send(null)
+rx.send(4)
+rx.send(5)
+
+expect(buffer).toBe('012345') // true
+```
+
+## FlatMap Operator
+Transforms all elements from an upstream publisher into a new publisher.
+
+```ts
+class Task {
+  readonly $isDone = new RXObservableValue(false)
+}
+
+const task = new Task()
+const $selectedTask = new RXObservableValue<Task | undefined>(undefined)
+let buffer = ''
+
+$selectedTask.pipe()
+  .skipNullable()
+  .flatMap(t => t.$isDone)
+  .onReceive(isDone => buffer = isDone + '')
+  .subscribe()
+
+expect(buffer).toBe('') // no submission: selectedTask is undefined
+
+$selectedTask.value = task
+expect(buffer).toBe('false') // buffer is updated with default value false
+
+task.$isDone.value = true
+expect(buffer).toBe('true') // buffer is updated with value true
+```
+
+## More examples
+You can find more examples in the test-folder: [https://github.com/Dittner/Flinker/tree/main/test/rx](https://github.com/Dittner/Flinker/tree/main/test/rx)
+
+## Install
+```code
 npm i flinker
 ```
 
-# License
+## License
 MIT

package/dist/esm/RX.js

@@ -1,8 +1,5 @@
 import { RXCombine, RXDelayedComplete, RXDelayedError, RXFrom, RXJustComplete, RXJustError, RXQueue, RXWaitUntilComplete } from './RXPublisher';
 export class RX {
-    //--------------------------------------
-    //  STATIC METHODS
-    //--------------------------------------
     static combine(...list) {
         return new RXCombine(list).asObservable;
     }

package/dist/esm/RXPublisher.js

@@ -1,21 +1,4 @@
 import { RXPipeline } from './RXPipeline';
-//WeakRef is not supported in RN
-// export class RXPipelineGarbage {
-//   static self = new RXPipelineGarbage()
-//   private readonly list = Array<WeakRef<RXAnyPipeline>>()
-//   private total = 0
-//
-//   register(p: RXAnyPipeline) {
-//     this.list.push(new WeakRef(p))
-//     this.total++
-//     this.log()
-//   }
-//
-//   log() {
-//     const disposedCount = this.list.reduce((res, ref) => ref.deref() ? res + 1 : res, 0)
-//     Logger.i('GC: disposed pipelines:', disposedCount + '/' + this.total)
-//   }
-// }
 const generateSUID = (() => {
     let value = 0;
     return () => {
@@ -40,7 +23,6 @@ export class RXPublisher {
     pipe() {
         const pipe = new RXPipeline(this);
         this.pipelines.push(pipe);
-        //RXPipelineGarbage.self.register(pipe)
         return pipe.asOperator;
     }
     didSubscribe(p) {

package/dist/esm/RXSubscriber.js

@@ -24,7 +24,7 @@ export class RXSubscriber {
     }
     onReceive(f) {
         if (this.isComplete)
-            throw new Error('RXSubscriber is complete: It can update onReceiveCallback');
+            throw new Error('RXSubscriber is complete: It can not update onReceiveCallback');
         else if (this.isSubscribed)
             throw new Error('RXSubscriber can not update onReceiveCallback: subscribe() is already evoked');
         this.onReceiveCallback = f;

package/dist/types/RXPublisher.d.ts

@@ -1,16 +1,16 @@
 import { type RXAnyOperatorProtocol, type RXOperatorProtocol } from './RXOperator';
 import { type RXAnyPipeline } from './RXPipeline';
 import { type RXObject, type RXObjectType } from './RX';
+export type SessionUID = number;
 export type AnyRXObservable = RXObservable<any, any>;
 export interface RXObservable<V, E> extends RXObject {
-    suid: RXPublisherUID;
+    suid: SessionUID;
     isComplete: boolean;
     pipe(): RXOperatorProtocol<V, E>;
 }
-export type RXPublisherUID = number;
 export type RXAnyPublisher = RXPublisher<any, any>;
 export declare class RXPublisher<V, E> implements RXObservable<V, E> {
-    readonly suid: RXPublisherUID;
+    readonly suid: number;
     readonly type: RXObjectType;
     protected readonly pipelines: RXAnyPipeline[];
     constructor();

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 export { RXAnySender, RXSender, RX, } from "./RX";
-export { AnyRXObservable, RXObservable, RXPublisherUID, RXPublisher, RXJustComplete, RXJustError, RXDelayedComplete, RXDelayedError, RXEmitter, RXSubject, RXBuffer, RXOperation, RXCombine, RXFrom, RXWaitUntilComplete, RXObservableEntity, RXObservableValue, RXAnyQueueOperator, RXQueueOperator, RXQueue, } from "./RXPublisher";
+export { AnyRXObservable, RXObservable, SessionUID, RXPublisher, RXJustComplete, RXJustError, RXDelayedComplete, RXDelayedError, RXEmitter, RXSubject, RXBuffer, RXOperation, RXCombine, RXFrom, RXWaitUntilComplete, RXObservableEntity, RXObservableValue, RXAnyQueueOperator, RXQueueOperator, RXQueue, } from "./RXPublisher";
 export { RXOperatorProtocol, RXAnyOperator, RXOperator, RXMap, RXFlatMap, RXForEach, RXSequent, RXParallel, RXFilter, RXSpread, RXSkipFirst, RXSkipNullable, RXRemoveDuplicates, RXDebounce, RXReplaceError, } from "./RXOperator";
 export { RXAnyPipeline, RXPipeline } from "./RXPipeline";
 export { ErrorMethod, CompleteMethod, SubscribeMethod, RXAnySubscriber, RXSubscriber } from "./RXSubscriber";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "flinker",
   "description": "RX.ts lib for building frontend apps",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Dittner/Flinker.git"
@@ -16,7 +16,6 @@
   },
   "homepage": "https://github.com/Dittner/Flinker",
   "private": false,
-  "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
   "types": "./dist/types/index.d.ts",
   "files": [
@@ -33,10 +32,6 @@
     "build:cjs": "tsc --module commonjs --target es5 --outDir dist/cjs"
   },
   "eslintConfig": {
-    "extends": [
-      "react-app",
-      "react-app/jest"
-    ]
   },
   "browserslist": {
     "production": [
@@ -52,7 +47,6 @@
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.6.3",
-    "@testing-library/react": "^16.2.0",
     "@testing-library/user-event": "^14.6.1",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.13.13",
@@ -60,9 +54,7 @@
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
     "ts-jest": "^29.3.0",
-    "typescript": "^5.8.2",
-    "@types/react": "^19.0.12",
-    "@types/react-dom": "^19.0.4"
+    "typescript": "^5.8.2"
   },
   "directories": {
     "test": "test"