publish. need to refactor .spec.ts files

Author: OhadC

.gitignore

@@ -0,0 +1,13 @@
+# Editor-specific
+.idea/
+*.iml
+*.sublime-project
+*.sublime-workspace
+.settings
+.vscode
+
+# Installed libs
+node_modules/
+
+# Generated
+dist/

.prettierrc

@@ -0,0 +1,7 @@
+{
+    "trailingComma": "es5",
+    "tabWidth": 4,
+    "semi": false,
+    "singleQuote": true,
+    "printWidth": 140
+}

package.json

@@ -0,0 +1,22 @@
+{
+    "name": "custom-rxjs-operators",
+    "version": "1.0.0",
+    "description": "",
+    "main": "index.js",
+    "scripts": {
+        "test": "cross-env TS_NODE_PROJECT=spec/tsconfig.json mocha --opts spec/default.opts \"src/operators/*.spec.ts\""
+    },
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "@types/chai": "^4.2.3",
+        "@types/mocha": "^5.2.7",
+        "chai": "^4.2.0",
+        "cross-env": "^6.0.0",
+        "mocha": "^6.2.1",
+        "rxjs": "^6.5.3",
+        "ts-node": "^8.4.1",
+        "tsconfig-paths": "^3.9.0",
+        "typescript": "^3.6.3"
+    }
+}

spec/default.opts

@@ -0,0 +1,9 @@
+--require ts-node/register
+--require tsconfig-paths/register
+
+--reporter dot
+
+--check-leaks
+
+--recursive
+--timeout 5000

spec/tsconfig.json

@@ -0,0 +1,3 @@
+{
+    "extends": "../tsconfig.json"
+}

src/index.ts

@@ -0,0 +1,3 @@
+import * as operators from './operators'
+
+export { operators }

src/operators/delay-and-take-last.spec.ts

@@ -0,0 +1,62 @@
+import { expect } from 'chai'
+import { TestScheduler } from 'rxjs/testing'
+import { delayAndTakeLast, wrappedWithDelay } from './delay-and-take-last'
+
+describe('delay-and-take-last', () => {
+    it('should not undelayed event', () => {
+        const testScheduler = new TestScheduler((actual, expected) => {
+            expect(actual).deep.equal(expected)
+        })
+
+        testScheduler.run(helpers => {
+            const { cold, expectObservable, expectSubscriptions } = helpers
+
+            const e1 = cold<wrappedWithDelay<string>>('-a--b--c---|', { a: { event: 'a' }, b: { event: 'b', delay: 0 }, c: { event: 'c' } })
+            const subs = '^----------!'
+            const expected = '-a--b--c---|'
+
+            expectObservable(e1.pipe(delayAndTakeLast())).toBe(expected)
+            expectSubscriptions(e1.subscriptions).toBe(subs)
+        })
+    })
+
+    it('should throw delayed event', () => {
+        const testScheduler = new TestScheduler((actual, expected) => {
+            expect(actual).deep.equal(expected)
+        })
+
+        testScheduler.run(helpers => {
+            const { cold, expectObservable, expectSubscriptions } = helpers
+
+            const e1 = cold<{
+                event: string
+                delay?: number
+            }>('-a--b--c---|', { a: { event: 'a' }, b: { event: 'b', delay: 10 }, c: { event: 'c' } })
+            const subs = '^----------!'
+            const expected = '-a-----c---|'
+
+            expectObservable(e1.pipe(delayAndTakeLast())).toBe(expected)
+            expectSubscriptions(e1.subscriptions).toBe(subs)
+        })
+    })
+
+    it('should emit delayed event', () => {
+        const testScheduler = new TestScheduler((actual, expected) => {
+            expect(actual).deep.equal(expected)
+        })
+
+        testScheduler.run(helpers => {
+            const { cold, expectObservable, expectSubscriptions } = helpers
+
+            const e1 = cold<{
+                event: string
+                delay?: number
+            }>('a---c|', { a: { event: 'a', delay: 2 }, c: { event: 'c' } })
+            const subs = '^----!'
+            const expected = '--a-c|'
+
+            expectObservable(e1.pipe(delayAndTakeLast())).toBe(expected)
+            expectSubscriptions(e1.subscriptions).toBe(subs)
+        })
+    })
+})

src/operators/delay-and-take-last.ts

@@ -0,0 +1,69 @@
+import { Observable, of, Subscription } from 'rxjs'
+import { delay } from 'rxjs/operators'
+
+// code based on https://rxjs-dev.firebaseapp.com/guide/v6/pipeable-operators
+
+export const delayAndTakeLast = () => <T>(source: Observable<wrappedWithDelay<T>>) =>
+    new Observable<T>(observer => {
+        let nextIndex = 0
+        let prevFiredIndex = -1
+        let delayedEvents: { index: number; event: T; subscription: Subscription }[] = []
+
+        function onDestroy() {
+            clearDelayedEvents()
+        }
+
+        function dispatch(value: T, index: number) {
+            clearDelayedEvents(index)
+            observer.next(value)
+            prevFiredIndex = index
+        }
+
+        function clearDelayedEvents(toIndex = Number.MAX_SAFE_INTEGER) {
+            delayedEvents = delayedEvents.filter(delayedEvent => {
+                if (delayedEvent.index > toIndex) {
+                    return true
+                } else {
+                    delayedEvent.subscription.unsubscribe()
+                    return false
+                }
+            })
+        }
+
+        return source.subscribe({
+            next(value) {
+                const index = nextIndex++
+
+                if (value.delay) {
+                    const subscription = of(0)
+                        .pipe(delay(value.delay))
+                        .subscribe(() => {
+                            if (prevFiredIndex < index) {
+                                dispatch(value.event, index)
+                            }
+                        })
+
+                    delayedEvents.push({
+                        event: value.event,
+                        index,
+                        subscription,
+                    })
+                } else {
+                    dispatch(value.event, index)
+                }
+            },
+            error(err) {
+                onDestroy()
+                observer.error(err)
+            },
+            complete() {
+                onDestroy()
+                observer.complete()
+            },
+        })
+    })
+
+export type wrappedWithDelay<T> = {
+    event: T
+    delay?: number
+}

src/operators/index.ts

@@ -0,0 +1,2 @@
+export * from './delay-and-take-last'
+export * from './unique-event-counter'

src/operators/unique-event-counter.spec.ts

@@ -0,0 +1,47 @@
+import { expect } from 'chai'
+import { TestScheduler } from 'rxjs/testing'
+import { uniqueEventCounter } from './unique-event-counter'
+
+describe('unique-event-counter', () => {
+    it('should register single clicks', () => {
+        const testScheduler = new TestScheduler((actual, expected) => {
+            expect(actual).deep.equal(expected)
+        })
+
+        testScheduler.run(helpers => {
+            const { cold, expectObservable, expectSubscriptions } = helpers
+
+            const e1 = cold<string>('-a--b--c-|')
+            const subs = '^--------!'
+            const expected = '-a--b--c-|'
+
+            expectObservable(e1.pipe(uniqueEventCounter(2, undefined, 1))).toBe(expected, {
+                a: { value: 'a', times: 1 },
+                b: { value: 'b', times: 1 },
+                c: { value: 'c', times: 1 },
+            })
+            expectSubscriptions(e1.subscriptions).toBe(subs)
+        })
+    })
+
+    it('should register single and double clicks', () => {
+        const testScheduler = new TestScheduler((actual, expected) => {
+            expect(actual).deep.equal(expected)
+        })
+
+        testScheduler.run(helpers => {
+            const { cold, expectObservable, expectSubscriptions } = helpers
+
+            const e1 = cold<string>('-aa--b---c----|')
+            const subs = '^-------------!'
+            const expected = '--a-----b---c-|'
+
+            expectObservable(e1.pipe(uniqueEventCounter(3, undefined, 2))).toBe(expected, {
+                a: { value: 'a', times: 2 },
+                b: { value: 'b', times: 1 },
+                c: { value: 'c', times: 1 },
+            })
+            expectSubscriptions(e1.subscriptions).toBe(subs)
+        })
+    })
+})