Merge branch 'master' into issue-171-adapter-replace

Author: dhilt

package-dist.json

@@ -1,6 +1,6 @@
 {
   "name": "ngx-ui-scroll",
-  "version": "1.11.0-rc",
+  "version": "1.11.0-rc.1",
   "description": "Infinite/virtual scroll for Angular",
   "main": "./bundles/ngx-ui-scroll.umd.js",
   "module": "./fesm5/ngx-ui-scroll.js",

package.json

@@ -14,7 +14,7 @@
     "deploy-app": "npm run build-app && firebase deploy",
     "preinstall": "cd server && npm install",
     "postinstall": "npm run build-app",
-    "pack:install": "npm run build && npm pack ./dist && npm install ngx-ui-scroll-1.11.0-rc.tgz --no-save",
+    "pack:install": "npm run build && npm pack ./dist && npm install ngx-ui-scroll-1.11.0-rc.1.tgz --no-save",
     "pack:start": "npm run pack:install && npm start",
     "build": "node build.js",
     "publish:lib": "npm run build && npm publish ./dist",

src/component/classes/buffer.ts

@@ -19,22 +19,23 @@ export class Buffer {
   eofSource: Subject<boolean>;
   minIndexUser: number;
   maxIndexUser: number;
+  startIndexUser: number;
+  startIndex: number;
 
-  private startIndex: number;
   private pristine: boolean;
   private cache: Cache;
   readonly logger: Logger;
 
-  constructor(settings: Settings, startIndex: number, logger: Logger, $items?: BehaviorSubject<Item[]>) {
+  constructor(settings: Settings, logger: Logger, $items?: BehaviorSubject<Item[]>) {
+    this.logger = logger;
     this.$items = $items || new BehaviorSubject<Item[]>([]);
     this.bofSource = new Subject<boolean>();
     this.eofSource = new Subject<boolean>();
     this.cache = new Cache(settings.itemSize, logger);
+    this.startIndexUser = settings.startIndex;
     this.minIndexUser = settings.minIndex;
     this.maxIndexUser = settings.maxIndex;
     this.reset();
-    this.startIndex = startIndex;
-    this.logger = logger;
   }
 
   dispose(forever?: boolean) {
@@ -54,14 +55,32 @@ export class Buffer {
     this.cache.reset();
     this.absMinIndex = this.minIndexUser;
     this.absMaxIndex = this.maxIndexUser;
-    if (typeof startIndex !== 'undefined') {
-      this.startIndex = startIndex;
-    }
+    this.setCurrentStartIndex(startIndex);
     this._bof = false;
     this._eof = false;
     this.pristine = false;
   }
 
+  setCurrentStartIndex(newStartIndex?: any) {
+    const min = this.minIndexUser;
+    const max = this.maxIndexUser;
+    const start = this.startIndexUser;
+    let index = Number(newStartIndex);
+    if (Number.isNaN(index)) {
+      this.logger.log(() => `fallback startIndex to settings.startIndex (${start})`);
+      index = start;
+    }
+    if (index < min) {
+      this.logger.log(() => `setting startIndex to settings.minIndex (${min}) because ${index} < ${min}`);
+      index = min;
+    }
+    if (index > max) {
+      this.logger.log(() => `setting startIndex to settings.maxIndex (${max}) because ${index} > ${max}`);
+      index = max;
+    }
+    this.startIndex = index;
+  }
+
   set items(items: Item[]) {
     this._items = items;
     this.$items.next(items);
@@ -227,6 +246,7 @@ export class Buffer {
       this.absMaxIndex -= toRemove.length;
     } else {
       this.absMinIndex += toRemove.length;
+      this.startIndex += toRemove.length;
     }
     if (!virtual) {
       this.items = result;

src/component/classes/state.ts

@@ -11,10 +11,8 @@ export class State implements IState {
 
   readonly version: string;
   private settings: Settings;
-  private logger: Logger;
 
   initTime: number;
-  startIndex: number;
 
   cycle: WorkflowCycleModel;
 
@@ -28,13 +26,11 @@ export class State implements IState {
     return Number(new Date()) - this.initTime;
   }
 
-  constructor(version: string, settings: Settings, logger: Logger, loopCount?: number, cycleCount?: number) {
+  constructor(version: string, settings: Settings, loopCount?: number, cycleCount?: number) {
     this.version = version;
     this.settings = settings;
-    this.logger = logger;
 
     this.initTime = Number(new Date());
-    this.setCurrentStartIndex(settings.startIndex);
 
     this.cycle = new WorkflowCycleModel(this.settings.instanceIndex, cycleCount || 1, loopCount || 0);
 
@@ -45,22 +41,4 @@ export class State implements IState {
     this.scrollState = new ScrollState();
   }
 
-  setCurrentStartIndex(newStartIndex: any) {
-    const { startIndex, minIndex, maxIndex } = this.settings;
-    let index = Number(newStartIndex);
-    if (Number.isNaN(index)) {
-      this.logger.log(() => `fallback startIndex to settings.startIndex (${startIndex})`);
-      index = startIndex;
-    }
-    if (index < minIndex) {
-      this.logger.log(() => `setting startIndex to settings.minIndex (${minIndex}) because ${index} < ${minIndex}`);
-      index = minIndex;
-    }
-    if (index > maxIndex) {
-      this.logger.log(() => `setting startIndex to settings.maxIndex (${maxIndex}) because ${index} > ${maxIndex}`);
-      index = maxIndex;
-    }
-    this.startIndex = index;
-  }
-
 }

src/component/classes/viewport.ts

@@ -49,9 +49,9 @@ export class Viewport {
     }
   }
 
-  reset(scrollPosition: number) {
+  reset(startIndex: number, scrollPosition: number) {
     this.setOffset();
-    this.paddings.reset(this.getSize(), this.state.startIndex, this.offset);
+    this.paddings.reset(this.getSize(), startIndex, this.offset);
     this.scrollPosition = this.paddings.backward.size || 0;
     this.state.scrollState.reset();
   }

src/component/inputs/validation.ts

@@ -147,7 +147,7 @@ const onFunctionWithXAndMoreArguments = (argsCount: number) => (value: any): Val
 
 const onOneOf = (tokens: string[], must: boolean) => (value: any, context: any): ValidatedValue => {
   const errors = [];
-  const isSet = typeof value !== 'undefined';
+  const isSet = value !== void 0;
   let noOneIsPresent = !isSet;
   if (!Array.isArray(tokens) || !tokens.length) {
     errors.push(`token list must be passed`);

src/component/interfaces/state.ts

@@ -29,17 +29,11 @@ export interface ScrollState {
 
 export interface State {
   version: string;
-
   initTime: number;
-  startIndex: number;
-
   cycle: WorkflowCycleModel;
-
   fetch: FetchModel;
   clip: ClipModel;
   render: RenderModel;
-
   scrollState: ScrollState;
-
   time: number;
 }

src/component/processes/adapter/_base.ts

@@ -14,7 +14,7 @@ export const getBaseAdapterProcess = (process: AdapterProcess) =>
 
     static process: AdapterProcess = process;
 
-    static parseInput<T>(scroller: Scroller, options: T): IParseInput<T> {
+    static parseInput<T>(scroller: Scroller, options: T, ignoreErrors = false): IParseInput<T> {
       const result: IParseInput<T> = {
         data: validate(options, ADAPTER_METHODS[process])
       };
@@ -27,11 +27,13 @@ export const getBaseAdapterProcess = (process: AdapterProcess) =>
           }), {} as T);
       } else {
         scroller.logger.log(() => result.data.showErrors());
-        scroller.workflow.call({
-          process,
-          status: ProcessStatus.error,
-          payload: { error: `Wrong argument of the "${process}" method call` }
-        });
+        if (!ignoreErrors) {
+          scroller.workflow.call({
+            process,
+            status: ProcessStatus.error,
+            payload: { error: `Wrong argument of the "${process}" method call` }
+          });
+        }
       }
 
       return result;

src/component/processes/adapter/reload.ts

@@ -8,9 +8,11 @@ export default class Reload extends getBaseAdapterProcess(AdapterProcess.reload)
     const { viewport, state, buffer } = scroller;
     const scrollPosition = viewport.scrollPosition;
 
-    state.setCurrentStartIndex(reloadIndex);
-    buffer.reset(true, state.startIndex);
-    viewport.reset(scrollPosition);
+    const { params } = Reload.parseInput(scroller, { reloadIndex }, true);
+    reloadIndex = params ? params.reloadIndex : void 0;
+
+    buffer.reset(true, reloadIndex);
+    viewport.reset(buffer.startIndex, scrollPosition);
 
     const payload: any = {};
     if (scroller.adapter.isLoading) {

src/component/processes/postFetch.ts

@@ -57,7 +57,7 @@ export default class PostFetch extends getBaseProcess(CommonProcess.postFetch) {
     if (items.length < fetch.count) {
       if (cycle.innerLoop.isInitial) {
         // let's treat initial poor fetch as startIndex-bof
-        fetchIndex = scroller.state.startIndex;
+        fetchIndex = buffer.startIndex;
       } else if ((fetch.first.index as number) < buffer.minIndex) { // normal bof
         fetchIndex = buffer.minIndex - items.length;
       }

src/component/processes/preFetch.ts

@@ -50,15 +50,15 @@ export default class PreFetch extends getBaseProcess(CommonProcess.preFetch) {
   }
 
   static getStartDelta(scroller: Scroller): number { // calculate size before start index
-    const { buffer, viewport: { offset }, state } = scroller;
+    const { buffer, viewport: { offset } } = scroller;
     let startDelta = 0;
     if (offset) {
       startDelta += offset;
     }
     if (!buffer.hasItemSize) {
       return startDelta;
     }
-    for (let index = buffer.finiteAbsMinIndex; index < state.startIndex; index++) {
+    for (let index = buffer.finiteAbsMinIndex; index < buffer.startIndex; index++) {
       startDelta += buffer.getSizeByIndex(index);
     }
     scroller.logger.log(() => [
@@ -70,7 +70,7 @@ export default class PreFetch extends getBaseProcess(CommonProcess.preFetch) {
   static setFirstIndex(scroller: Scroller) {
     const { state, buffer } = scroller;
     const { positions: { start }, first } = state.fetch;
-    let firstIndex = state.startIndex;
+    let firstIndex = buffer.startIndex;
     let firstIndexPosition = 0;
     if (state.cycle.innerLoop.isInitial) {
       scroller.logger.log(`skipping fetch backward direction [initial loop]`);
@@ -114,12 +114,12 @@ export default class PreFetch extends getBaseProcess(CommonProcess.preFetch) {
   }
 
   static setLastIndex(scroller: Scroller) {
-    const { state: { fetch, startIndex, cycle }, buffer, settings } = scroller;
+    const { state: { fetch, cycle }, buffer, settings } = scroller;
     const { positions: { relative, end }, first, last } = fetch;
     let lastIndex;
     if (!buffer.hasItemSize) {
       // just to fetch forward bufferSize items if neither averageItemSize nor itemSize are present
-      lastIndex = startIndex + settings.bufferSize - 1;
+      lastIndex = buffer.startIndex + settings.bufferSize - 1;
       scroller.logger.log(`forcing fetch forward direction [no item size]`);
     } else {
       let index = first.indexBuffer as number;

src/component/scroller.ts

@@ -1,4 +1,4 @@
-import { Observable, Subscription, Observer, Subject } from 'rxjs';
+import { Observable, Subject } from 'rxjs';
 
 import { Datasource } from './classes/datasource';
 import { Settings } from './classes/settings';
@@ -52,8 +52,8 @@ export class Scroller {
     this.settings = new Settings(datasource.settings, datasource.devSettings, ++instanceCount);
     this.logger = new Logger(this, version);
     this.routines = new Routines(this.settings);
-    this.state = new State(version, this.settings, this.logger, loopCount, cycleCount);
-    this.buffer = new Buffer(this.settings, this.state.startIndex, this.logger, $items);
+    this.state = new State(version, this.settings, loopCount, cycleCount);
+    this.buffer = new Buffer(this.settings, this.logger, $items);
     this.viewport = new Viewport(element, this.settings, this.routines, this.state, this.logger);
     this.logger.object('uiScroll settings object', this.settings, true);
 
@@ -83,7 +83,7 @@ export class Scroller {
   }
 
   init(dispose$: Subject<void>, onAdapterRun$?: Observable<ProcessSubject>) {
-    this.viewport.reset(0);
+    this.viewport.reset(this.buffer.startIndex, 0);
     this.logger.stat('initialization');
     this.adapter.init(this.buffer, this.logger, dispose$, onAdapterRun$);
   }

src/ui-scroll.version.ts

@@ -1 +1 @@
-export default '1.11.0-rc';
+export default '1.11.0-rc.1';

tests/adapter.reset.spec.ts

@@ -124,7 +124,7 @@ const checkReset = (config: TestBedConfig, misc: Misc, oldCheck: ICheckReset) =>
   const { settings, get, interruption } = config.custom;
   let firstIndex = oldCheck.firstVisible;
   let lastIndex = oldCheck.lastVisible;
-  if (settings && typeof settings.startIndex !== 'undefined') {
+  if (settings && settings.startIndex !== void 0) {
     firstIndex = settings.startIndex;
     lastIndex = firstIndex + (oldCheck.lastVisible - oldCheck.firstVisible);
   }

tests/bug.spec.ts

@@ -217,4 +217,31 @@ describe('Bug Spec', () => {
     })
   );
 
+  describe('remove with increase', () =>
+    makeTest({
+      title: 'should shift startIndex',
+      config: {
+        datasourceName: 'limited-1-100-no-delay',
+        datasourceSettings: { adapter: true, bufferSize: 5, startIndex: 1, minIndex: 1, maxIndex: 100 },
+      },
+      it: (misc: Misc) => async (done: Function) => {
+        await misc.relaxNext();
+        const { settings: { minIndex, maxIndex }, buffer, buffer: { startIndex } } = misc.scroller;
+        const toRemove = [1, 2, 3, 4, 5];
+        await misc.adapter.remove({
+          predicate: ({ $index }) => toRemove.includes($index),
+          increase: true
+        });
+        (misc.datasource as any).setProcessGet((result: IndexedItem[]) =>
+          removeItems(result, toRemove, minIndex, maxIndex, true)
+        );
+        expect(buffer.startIndex).toBe(startIndex + toRemove.length);
+        await misc.scrollMinMax();
+        const maxItemsCount = Math.ceil(misc.getViewportSize() * 2 / misc.getItemSize());
+        expect(buffer.size).toBeLessThan(maxItemsCount);
+        done();
+      }
+    })
+  );
+
 });