@haiilo/catalyst 3.0.0 → 3.0.2

package/dist/components/cat-scrollable2.js

@@ -682,6 +682,157 @@ class AnonymousSubject extends Subject {
     }
 }
 
+const dateTimestampProvider = {
+    now() {
+        return (dateTimestampProvider.delegate || Date).now();
+    },
+    delegate: undefined,
+};
+
+class Action extends Subscription {
+    constructor(scheduler, work) {
+        super();
+    }
+    schedule(state, delay = 0) {
+        return this;
+    }
+}
+
+const intervalProvider = {
+    setInterval(handler, timeout, ...args) {
+        const { delegate } = intervalProvider;
+        if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) {
+            return delegate.setInterval(handler, timeout, ...args);
+        }
+        return setInterval(handler, timeout, ...args);
+    },
+    clearInterval(handle) {
+        const { delegate } = intervalProvider;
+        return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle);
+    },
+    delegate: undefined,
+};
+
+class AsyncAction extends Action {
+    constructor(scheduler, work) {
+        super(scheduler, work);
+        this.scheduler = scheduler;
+        this.work = work;
+        this.pending = false;
+    }
+    schedule(state, delay = 0) {
+        if (this.closed) {
+            return this;
+        }
+        this.state = state;
+        const id = this.id;
+        const scheduler = this.scheduler;
+        if (id != null) {
+            this.id = this.recycleAsyncId(scheduler, id, delay);
+        }
+        this.pending = true;
+        this.delay = delay;
+        this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);
+        return this;
+    }
+    requestAsyncId(scheduler, _id, delay = 0) {
+        return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
+    }
+    recycleAsyncId(_scheduler, id, delay = 0) {
+        if (delay != null && this.delay === delay && this.pending === false) {
+            return id;
+        }
+        intervalProvider.clearInterval(id);
+        return undefined;
+    }
+    execute(state, delay) {
+        if (this.closed) {
+            return new Error('executing a cancelled action');
+        }
+        this.pending = false;
+        const error = this._execute(state, delay);
+        if (error) {
+            return error;
+        }
+        else if (this.pending === false && this.id != null) {
+            this.id = this.recycleAsyncId(this.scheduler, this.id, null);
+        }
+    }
+    _execute(state, _delay) {
+        let errored = false;
+        let errorValue;
+        try {
+            this.work(state);
+        }
+        catch (e) {
+            errored = true;
+            errorValue = e ? e : new Error('Scheduled action threw falsy error');
+        }
+        if (errored) {
+            this.unsubscribe();
+            return errorValue;
+        }
+    }
+    unsubscribe() {
+        if (!this.closed) {
+            const { id, scheduler } = this;
+            const { actions } = scheduler;
+            this.work = this.state = this.scheduler = null;
+            this.pending = false;
+            arrRemove(actions, this);
+            if (id != null) {
+                this.id = this.recycleAsyncId(scheduler, id, null);
+            }
+            this.delay = null;
+            super.unsubscribe();
+        }
+    }
+}
+
+class Scheduler {
+    constructor(schedulerActionCtor, now = Scheduler.now) {
+        this.schedulerActionCtor = schedulerActionCtor;
+        this.now = now;
+    }
+    schedule(work, delay = 0, state) {
+        return new this.schedulerActionCtor(this, work).schedule(state, delay);
+    }
+}
+Scheduler.now = dateTimestampProvider.now;
+
+class AsyncScheduler extends Scheduler {
+    constructor(SchedulerAction, now = Scheduler.now) {
+        super(SchedulerAction, now);
+        this.actions = [];
+        this._active = false;
+        this._scheduled = undefined;
+    }
+    flush(action) {
+        const { actions } = this;
+        if (this._active) {
+            actions.push(action);
+            return;
+        }
+        let error;
+        this._active = true;
+        do {
+            if ((error = action.execute(action.state, action.delay))) {
+                break;
+            }
+        } while ((action = actions.shift()));
+        this._active = false;
+        if (error) {
+            while ((action = actions.shift())) {
+                action.unsubscribe();
+            }
+            throw error;
+        }
+    }
+}
+
+const asyncScheduler = new AsyncScheduler(AsyncAction);
+const async = asyncScheduler;
+
 const EMPTY = new Observable((subscriber) => subscriber.complete());
 
 function isScheduler(value) {
@@ -1041,6 +1192,10 @@ function from(input, scheduler) {
     return scheduler ? scheduled(input, scheduler) : innerFrom(input);
 }
 
+function isValidDate(value) {
+    return value instanceof Date && !isNaN(value);
+}
+
 function map(project, thisArg) {
     return operate((source, subscriber) => {
         let index = 0;
@@ -1173,6 +1328,36 @@ function isEventTarget(target) {
     return isFunction(target.addEventListener) && isFunction(target.removeEventListener);
 }
 
+function timer(dueTime = 0, intervalOrScheduler, scheduler = async) {
+    let intervalDuration = -1;
+    if (intervalOrScheduler != null) {
+        if (isScheduler(intervalOrScheduler)) {
+            scheduler = intervalOrScheduler;
+        }
+        else {
+            intervalDuration = intervalOrScheduler;
+        }
+    }
+    return new Observable((subscriber) => {
+        let due = isValidDate(dueTime) ? +dueTime - scheduler.now() : dueTime;
+        if (due < 0) {
+            due = 0;
+        }
+        let n = 0;
+        return scheduler.schedule(function () {
+            if (!subscriber.closed) {
+                subscriber.next(n++);
+                if (0 <= intervalDuration) {
+                    this.schedule(undefined, intervalDuration);
+                }
+                else {
+                    subscriber.complete();
+                }
+            }
+        }, due);
+    });
+}
+
 function merge(...args) {
     const scheduler = popScheduler(args);
     const concurrent = popNumber(args, Infinity);
@@ -1194,6 +1379,44 @@ function filter(predicate, thisArg) {
     });
 }
 
+function audit(durationSelector) {
+    return operate((source, subscriber) => {
+        let hasValue = false;
+        let lastValue = null;
+        let durationSubscriber = null;
+        let isComplete = false;
+        const endDuration = () => {
+            durationSubscriber === null || durationSubscriber === void 0 ? void 0 : durationSubscriber.unsubscribe();
+            durationSubscriber = null;
+            if (hasValue) {
+                hasValue = false;
+                const value = lastValue;
+                lastValue = null;
+                subscriber.next(value);
+            }
+            isComplete && subscriber.complete();
+        };
+        const cleanupDuration = () => {
+            durationSubscriber = null;
+            isComplete && subscriber.complete();
+        };
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            hasValue = true;
+            lastValue = value;
+            if (!durationSubscriber) {
+                innerFrom(durationSelector(value)).subscribe((durationSubscriber = createOperatorSubscriber(subscriber, endDuration, cleanupDuration)));
+            }
+        }, () => {
+            isComplete = true;
+            (!hasValue || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
+        }));
+    });
+}
+
+function auditTime(duration, scheduler = asyncScheduler) {
+    return audit(() => timer(duration, scheduler));
+}
+
 function distinctUntilChanged(comparator, keySelector = identity) {
     comparator = comparator !== null && comparator !== void 0 ? comparator : defaultCompare;
     return operate((source, subscriber) => {
@@ -1233,6 +1456,8 @@ const CatScrollable = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement
     this.scrolledBottom = createEvent(this, "scrolledBottom", 7);
     this.init = new Subject();
     this.destroyed = new Subject();
+    this.resizedEntries = new Subject();
+    this.resizedObserver = new ResizeObserver(entries => this.resizedEntries.next(entries));
     /** Flags to disable/enable scroll shadowX. */
     this.noShadowX = false;
     /** Flags to disable/enable scroll shadowY. */
@@ -1255,13 +1480,17 @@ const CatScrollable = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement
   componentDidRender() {
     if (this.scrollElement) {
       this.scrolled = fromEvent(this.scrollElement, 'scroll').pipe(takeUntil(this.destroyed));
+      this.resizedObserver.observe(this.scrollElement);
+    }
+    if (this.scrollWrapperElement) {
+      this.resizedObserver.observe(this.scrollWrapperElement);
     }
-    this.attachEmitter('left', this.scrolledLeft, this.scrolledBuffer);
-    this.attachEmitter('right', this.scrolledRight, this.scrolledBuffer);
-    this.attachEmitter('bottom', this.scrolledBottom, this.scrolledBuffer);
-    this.attachEmitter('top', this.scrolledTop, this.scrolledBuffer);
-    merge(this.init, this.scrolled)
-      .pipe(map(() => ({
+    this.attachEmitter('left', this.scrolledLeft);
+    this.attachEmitter('right', this.scrolledRight);
+    this.attachEmitter('bottom', this.scrolledBottom);
+    this.attachEmitter('top', this.scrolledTop);
+    merge(this.init, this.scrolled, this.resizedEntries)
+      .pipe(auditTime(CatScrollable.THROTTLE), map(() => ({
       top: this.getScrollOffset('top') > 0,
       left: this.getScrollOffset('left') > 0,
       right: this.getScrollOffset('right') > 0,
@@ -1283,6 +1512,7 @@ const CatScrollable = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement
     this.init.complete();
     this.destroyed.next();
     this.destroyed.complete();
+    this.resizedObserver.disconnect();
   }
   render() {
     return [
@@ -1295,13 +1525,9 @@ const CatScrollable = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement
         } }, h("slot", null))
     ];
   }
-  attachEmitter(from, emitter, buffer) {
-    merge(this.init, this.scrolled)
-      .pipe(map(() => this.getScrollOffset(from)))
-      .pipe(map(offset => offset <= buffer))
-      .pipe(distinctUntilChanged())
-      .pipe(filter(isLower => isLower))
-      .pipe(takeUntil(this.destroyed))
+  attachEmitter(from, emitter) {
+    merge(this.init, this.scrolled, this.resizedEntries)
+      .pipe(auditTime(CatScrollable.THROTTLE), map(() => this.getScrollOffset(from)), map(offset => offset <= this.scrolledBuffer), distinctUntilChanged(), filter(isLower => isLower), takeUntil(this.destroyed))
       .subscribe(() => emitter.emit());
   }
   getScrollOffset(from) {
@@ -1340,6 +1566,7 @@ const CatScrollable = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement
     "noScrolledInit": [4, "no-scrolled-init"],
     "scrolledBuffer": [2, "scrolled-buffer"]
   }]);
+CatScrollable.THROTTLE = 50;
 function defineCustomElement() {
   if (typeof customElements === "undefined") {
     return;
@@ -1354,6 +1581,6 @@ function defineCustomElement() {
   } });
 }
 
-export { CatScrollable as C, EMPTY as E, Observable as O, Subscription as S, mergeMap as a, arrRemove as b, createOperatorSubscriber as c, defineCustomElement as d, createErrorClass as e, from as f, mergeAll as g, innerFrom as h, isScheduler as i, filter as j, identity as k, isFunction as l, map as m, noop as n, operate as o, popScheduler as p, Subject as q, distinctUntilChanged as r };
+export { CatScrollable as C, EMPTY as E, Subject as S, mergeMap as a, asyncScheduler as b, createOperatorSubscriber as c, defineCustomElement as d, createErrorClass as e, from as f, mergeAll as g, filter as h, innerFrom as i, identity as j, isFunction as k, distinctUntilChanged as l, map as m, noop as n, operate as o, popScheduler as p, timer as t };
 
 //# sourceMappingURL=cat-scrollable2.js.map