diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
deleted file mode 100644
index 3ed7c975..00000000
--- a/.github/workflows/build.yml
+++ /dev/null
@@ -1,39 +0,0 @@
-name: vscroll build
-
-on:
- push:
- branches:
- - "**"
- pull_request:
- branches: [main]
- workflow_dispatch:
- inputs:
- cause:
- description: "Reason"
- required: true
- default: "Manual triggering"
-
-jobs:
- build:
- runs-on: ubuntu-latest
- strategy:
- matrix:
- node-version: [20.x]
- steps:
- - name: Dispatched?
- if: ${{ github.event_name == 'workflow_dispatch' }}
- run: |
- echo "This is dispatched"
- echo "Build reason: ${{ github.event.inputs.cause }}"
-
- - name: Checkout
- uses: actions/checkout@v4
-
- - name: Use Node.js ${{ matrix.node-version }}
- uses: actions/setup-node@v4
- with:
- node-version: ${{ matrix.node-version }}
-
- - run: npm ci
- - run: npm run build
- - run: npm test
diff --git a/.github/workflows/general.yml b/.github/workflows/general.yml
new file mode 100644
index 00000000..597e26ad
--- /dev/null
+++ b/.github/workflows/general.yml
@@ -0,0 +1,58 @@
+name: vscroll build and tests
+
+on:
+ pull_request:
+ workflow_dispatch:
+ inputs:
+ cause:
+ description: "Reason"
+ required: true
+ default: "Manual triggering"
+
+jobs:
+ build_and_tests:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Dispatched?
+ if: ${{ github.event_name == 'workflow_dispatch' }}
+ run: |
+ echo "This is dispatched"
+ echo "Test reason: ${{ github.event.inputs.cause }}"
+
+ - name: Checkout
+ uses: actions/checkout@v4
+
+ - name: Use Node.js 22.x
+ uses: actions/setup-node@v4
+ with:
+ node-version: 22.x
+
+ - name: Install root dependencies
+ run: npm ci
+
+ - name: Lint
+ run: npm run lint
+
+ - name: Build
+ run: npm run build
+
+ - name: Install test dependencies
+ run: cd tests && npm ci
+
+ - name: Run unit tests
+ run: npm run test:unit
+
+ - name: Install Playwright Browsers
+ run: cd tests && npx playwright install --with-deps chromium
+
+ - name: Run e2e tests
+ run: npm run test:e2e
+
+ - name: Upload Playwright Report
+ uses: actions/upload-artifact@v4
+ if: ${{ !cancelled() }}
+ with:
+ name: playwright-report
+ path: tests/e2e/playwright-report/
+ retention-days: 30
+
diff --git a/.gitignore b/.gitignore
index 9bb67705..e0afc50e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,5 @@ node_modules
.vscode
*.tgz
.DS_Store
+tests/e2e/playwright-report
+tests/e2e/test-results
diff --git a/.husky/pre-commit b/.husky/pre-commit
new file mode 100644
index 00000000..2312dc58
--- /dev/null
+++ b/.husky/pre-commit
@@ -0,0 +1 @@
+npx lint-staged
diff --git a/.prettierrc b/.prettierrc
new file mode 100644
index 00000000..ffe8ad35
--- /dev/null
+++ b/.prettierrc
@@ -0,0 +1,7 @@
+{
+ "tabWidth": 2,
+ "singleQuote": true,
+ "arrowParens": "avoid",
+ "trailingComma": "none",
+ "printWidth": 100
+}
diff --git a/build.js b/build.js
index 01dc8a8c..9c3c623a 100644
--- a/build.js
+++ b/build.js
@@ -10,7 +10,7 @@ const CONF_DIR = 'build';
const configJsonString = readFileSync('./package.json', { encoding: 'utf8' });
const config = JSON.parse(configJsonString);
-// Package version
+// Package version
shell.echo('Setup package version');
const versionContent = `export default {
name: '${config.name}',
diff --git a/demo/window-test.html b/demo/window-test.html
new file mode 100644
index 00000000..69c8ca3c
--- /dev/null
+++ b/demo/window-test.html
@@ -0,0 +1,184 @@
+
+
+
+
+ vscroll window viewport test
+
+
+
+
+
+
+
+
Window Viewport Test
+
html.clientHeight: -
+
html.scrollHeight: -
+
window.innerHeight: -
+
Buffer size: -
+
Fetches: 0
+
- = {
- buffer: Buffer
- ,
- state: State,
- viewport: Viewport,
- logger: Logger,
- adapterRun$?: Reactive,
- getWorkflow?: WorkflowGetter
-
-}
-
-const ADAPTER_PROPS_STUB = getDefaultAdapterProps();
-const ALLOWED_METHODS_WHEN_PAUSED = ADAPTER_PROPS_STUB.filter(v => !!v.allowedWhenPaused).map(v => v.name);
-
-const _has = (obj: unknown, prop: string): boolean =>
- !!obj && typeof obj === 'object' && Object.prototype.hasOwnProperty.call(obj, prop);
-
-const convertAppendArgs =
- (prepend: boolean, options: unknown, eof?: boolean) => {
- let result = options as AdapterAppendOptions
- & AdapterPrependOptions
- ;
- if (!_has(options, 'items')) {
- const items = !Array.isArray(options) ? [options] : options;
- result = prepend ? { items, bof: eof } : { items, eof: eof };
- }
- return result;
-};
-
-const convertRemoveArgs =
- (options: AdapterRemoveOptions
- | ItemsPredicate
- ) => {
- if (!(_has(options, 'predicate') || _has(options, 'indexes'))) {
- const predicate = options as ItemsPredicate
- ;
- options = { predicate };
- }
- return options;
-};
-
-export class Adapter
- implements IAdapter
- {
- private externalContext: IAdapter
- ;
- private logger: Logger;
- private getWorkflow: WorkflowGetter
- ;
- private reloadCounter: number;
- private source: { [key: string]: Reactive } = {}; // for Reactive props
- private box: { [key: string]: unknown } = {}; // for Scalars over Reactive props
- private demand: { [key: string]: unknown } = {}; // for Scalars on demand
- private disposed: boolean;
-
- // eslint-disable-next-line @typescript-eslint/no-unused-vars
- setFirstOrLastVisible = (_: { first?: boolean, last?: boolean, workflow?: ScrollerWorkflow }) => { };
-
- get workflow(): ScrollerWorkflow
- {
- return this.getWorkflow();
- }
- get reloadCount(): number {
- return this.reloadCounter;
- }
- get reloadId(): string {
- return this.id + '.' + this.reloadCounter;
- }
-
- id: number;
- mock: boolean;
- augmented: boolean;
- version: string;
- init: boolean;
- init$: Reactive;
- packageInfo: IPackages;
- itemsCount: number;
- bufferInfo: IBufferInfo;
- isLoading: boolean;
- isLoading$: Reactive;
- loopPending: boolean;
- loopPending$: Reactive;
- firstVisible: ItemAdapter
- ;
- firstVisible$: Reactive>;
- lastVisible: ItemAdapter
- ;
- lastVisible$: Reactive>;
- bof: boolean;
- bof$: Reactive;
- eof: boolean;
- eof$: Reactive;
- paused: boolean;
- paused$: Reactive;
-
- private relax$: Reactive | null;
- private relaxRun: Promise | null;
-
- private getPromisifiedMethod(method: MethodResolver, args: unknown[]) {
- return new Promise(resolve => {
- if (this.relax$) {
- this.relax$.once(value => resolve(value));
- }
- method.apply(this, args);
- });
- }
-
- private getWorkflowRunnerMethod(method: MethodResolver, name: AdapterPropName) {
- return (...args: unknown[]): Promise => {
- if (!this.relax$) {
- this.logger?.log?.(() => 'scroller is not initialized: ' + name + ' method is ignored');
- return Promise.resolve(methodPreResult);
- }
- if (this.paused && !ALLOWED_METHODS_WHEN_PAUSED.includes(name)) {
- this.logger?.log?.(() => 'scroller is paused: ' + name + ' method is ignored');
- return Promise.resolve(methodPausedResult);
-
- }
- return this.getPromisifiedMethod(method, args);
- };
- }
-
- constructor(context: IAdapter
- | null, getWorkflow: WorkflowGetter
- , logger: Logger) {
- this.getWorkflow = getWorkflow;
- this.logger = logger;
- this.relax$ = null;
- this.relaxRun = null;
- this.reloadCounter = 0;
- const contextId = context?.id || -1;
-
- // public context (if exists) should provide access to Reactive props config by id
- const reactivePropsStore = context && reactiveConfigStorage.get(context.id) || {};
-
- // the Adapter initialization should not trigger "wanted" props setting;
- // after the initialization is completed, "wanted" functionality must be unblocked
- wantedUtils.setBlock(true, contextId);
-
- // make array of the original values from public context if present
- const adapterProps = context
- ? ADAPTER_PROPS_STUB.map(prop => {
- let value = context[prop.name];
- // if context is augmented, we need to replace external reactive props with inner ones
- if (context.augmented) {
- const reactiveProp = reactivePropsStore[prop.name];
- if (reactiveProp) {
- value = reactiveProp.default as Reactive; // boolean doesn't matter here
- }
- }
- return ({ ...prop, value });
- })
- : getDefaultAdapterProps();
-
- // restore default reactive props if they were configured
- Object.entries(reactivePropsStore).forEach(([key, value]) => {
- const prop = adapterProps.find(({ name }) => name === key);
- if (prop && value) {
- prop.value = value.default;
- }
- });
-
- // Scalar permanent props
- adapterProps
- .filter(({ type, permanent }) => type === AdapterPropType.Scalar && permanent)
- .forEach(({ name, value }: IAdapterProp) =>
- Object.defineProperty(this, name, {
- configurable: true,
- get: () => value
- })
- );
-
- // Reactive props: store original values in "source" container, to avoid extra .get() calls on scalar twins set
- adapterProps
- .filter(prop => prop.type === AdapterPropType.Reactive)
- .forEach(({ name, value }: IAdapterProp) => {
- this.source[name] = value as Reactive;
- Object.defineProperty(this, name, {
- configurable: true,
- get: () => this.source[name]
- });
- });
-
- // for "wanted" props that can be explicitly requested for the first time after the Adapter initialization,
- // an implicit calculation of the initial value is required;
- // so this method should be called when accessing the "wanted" props through one of the following getters
- const processWanted = (prop: IAdapterProp) => {
- if (wantedUtils.setBox(prop, contextId)) {
- if ([AdapterPropName.firstVisible, AdapterPropName.firstVisible$].some(n => n === prop.name)) {
- this.setFirstOrLastVisible({ first: true });
- } else if ([AdapterPropName.lastVisible, AdapterPropName.lastVisible$].some(n => n === prop.name)) {
- this.setFirstOrLastVisible({ last: true });
- }
- }
- };
-
- // Scalar props that have Reactive twins
- // 1) reactive props (from "source") should be triggered on set
- // 2) scalars should use "box" container on get
- // 3) "wanted" scalars should also run wanted-related logic on get
- adapterProps
- .filter(prop => prop.type === AdapterPropType.Scalar && !!prop.reactive)
- .forEach((prop: IAdapterProp) => {
- const { name, value, reactive } = prop;
- this.box[name] = value;
- Object.defineProperty(this, name, {
- configurable: true,
- set: (newValue: unknown) => {
- if (newValue !== this.box[name]) {
- this.box[name] = newValue;
- this.source[reactive as AdapterPropName].set(newValue);
- // need to emit new value through the configured reactive prop if present
- const reactiveProp = reactivePropsStore[reactive as AdapterPropName];
- if (reactiveProp) {
- reactiveProp.emit(reactiveProp.source, newValue);
- }
- }
- },
- get: () => {
- processWanted(prop);
- return this.box[name];
- }
- });
- });
-
- // Scalar props on-demand
- // these scalars should use "demand" container
- // setting defaults should be overridden on init()
- adapterProps
- .filter(prop => prop.type === AdapterPropType.Scalar && prop.onDemand)
- .forEach(({ name, value }: IAdapterProp) => {
- this.demand[name] = value;
- Object.defineProperty(this, name, {
- configurable: true,
- get: () => this.demand[name]
- });
- });
-
- if (!context) {
- return;
- }
-
- // Adapter public context augmentation
- adapterProps
- .forEach((prop: IAdapterProp) => {
- const { name, type, permanent } = prop;
- let value = (this as IAdapter)[name];
- if (type === AdapterPropType.Function) {
- value = (value as () => void).bind(this);
- } else if (type === AdapterPropType.WorkflowRunner) {
- value = this.getWorkflowRunnerMethod(value as MethodResolver, name);
- } else if (type === AdapterPropType.Reactive && reactivePropsStore[name]) {
- value = (context as IAdapter)[name];
- } else if (name === AdapterPropName.augmented) {
- value = true;
- }
- const nonPermanentScalar = !permanent && type === AdapterPropType.Scalar;
- Object.defineProperty(context, name, {
- configurable: true,
- get: () => {
- processWanted(prop); // consider accessing "wanted" Reactive props
- if (nonPermanentScalar) {
- return (this as IAdapter)[name]; // non-permanent Scalars should be taken in runtime
- }
- return value; // other props (Reactive/Functions/WorkflowRunners) can be defined once
- }
- });
- });
-
- this.externalContext = context;
- wantedUtils.setBlock(false, contextId);
- }
-
- initialize(
- { buffer, state, viewport, logger, adapterRun$, getWorkflow }: InitializationParams
-
- ): void {
- // buffer
- Object.defineProperty(this.demand, AdapterPropName.itemsCount, {
- get: () => buffer.getVisibleItemsCount()
- });
- Object.defineProperty(this.demand, AdapterPropName.bufferInfo, {
- get: (): IBufferInfo => ({
- firstIndex: buffer.firstIndex,
- lastIndex: buffer.lastIndex,
- minIndex: buffer.minIndex,
- maxIndex: buffer.maxIndex,
- absMinIndex: buffer.absMinIndex,
- absMaxIndex: buffer.absMaxIndex,
- defaultSize: buffer.defaultSize,
- })
- });
- this.bof = buffer.bof.get();
- buffer.bof.on(bof => this.bof = bof);
- this.eof = buffer.eof.get();
- buffer.eof.on(eof => this.eof = eof);
-
- // state
- Object.defineProperty(this.demand, AdapterPropName.packageInfo, {
- get: () => state.packageInfo
- });
- this.loopPending = state.cycle.innerLoop.busy.get();
- state.cycle.innerLoop.busy.on(busy => this.loopPending = busy);
- this.isLoading = state.cycle.busy.get();
- state.cycle.busy.on(busy => this.isLoading = busy);
- this.paused = state.paused.get();
- state.paused.on(paused => this.paused = paused);
-
- //viewport
- this.setFirstOrLastVisible = ({ first, last, workflow }) => {
- if ((!first && !last) || workflow?.call?.interrupted) {
- return;
- }
- const token = first ? AdapterPropName.firstVisible : AdapterPropName.lastVisible;
- if (!wantedUtils.getBox(this.externalContext?.id)?.[token]) {
- return;
- }
- if (buffer.items.some(({ element }) => !element)) {
- logger.log('skipping first/lastVisible set because not all buffered items are rendered at this moment');
- return;
- }
- const direction = first ? Direction.backward : Direction.forward;
- const { item } = viewport.getEdgeVisibleItem(buffer.items, direction);
- if (!item || item.element !== this[token].element) {
- this[token] = (item ? item.get() : EMPTY_ITEM) as ItemAdapter
- ;
- }
- };
-
- // logger
- this.logger = logger;
-
- // self-pending subscription; set up only on the very first init
- if (adapterRun$) {
- if (!this.relax$) {
- this.relax$ = new Reactive();
- }
- const relax$ = this.relax$;
- adapterRun$.on(({ status, payload }) => {
- let unSubRelax = () => { };
- if (status === ProcessStatus.start) {
- unSubRelax = this.isLoading$.on(value => {
- if (!value) {
- unSubRelax();
- relax$.set({ success: true, immediate: false, details: null });
- }
- });
- } else if (status === ProcessStatus.done || status === ProcessStatus.error) {
- unSubRelax();
- relax$.set({
- success: status !== ProcessStatus.error,
- immediate: true,
- details: status === ProcessStatus.error && payload ? String(payload.error) : null
- });
- }
- });
- }
-
- // workflow getter
- if (getWorkflow) {
- this.getWorkflow = getWorkflow;
- }
-
- // init
- this.init = true;
- }
-
- dispose(): void {
- if (this.relax$) {
- this.relax$.dispose();
- }
- if (this.externalContext) {
- this.resetContext();
- }
- Object.getOwnPropertyNames(this).forEach(prop => {
- delete (this as Record)[prop];
- });
- this.disposed = true;
- }
-
- resetContext(): void {
- const reactiveStore = reactiveConfigStorage.get(this.externalContext?.id);
- ADAPTER_PROPS_STUB
- .forEach(({ type, permanent, name, value }) => {
- // assign initial values to non-reactive non-permanent props
- if (type !== AdapterPropType.Reactive && !permanent) {
- Object.defineProperty(this.externalContext, name, {
- configurable: true,
- get: () => value
- });
- }
- // reset reactive props
- if (type === AdapterPropType.Reactive && reactiveStore) {
- const property = reactiveStore[name];
- if (property) {
- property.default.reset();
- property.emit(property.source, property.default.get());
- }
- }
- });
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- reset(options?: IDatasourceOptional): any {
- this.reloadCounter++;
- this.logger.logAdapterMethod('reset', options, ` of ${this.reloadId}`);
- this.workflow.call({
- process: AdapterProcess.reset,
- status: ProcessStatus.start,
- payload: { options }
- });
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- reload(options?: number | string): any {
- this.reloadCounter++;
- this.logger.logAdapterMethod('reload', options, ` of ${this.reloadId}`);
- this.workflow.call({
- process: AdapterProcess.reload,
- status: ProcessStatus.start,
- payload: { options }
- });
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- append(_options: AdapterAppendOptions
- | unknown, eof?: boolean): any {
- const options = convertAppendArgs(false, _options, eof); // support old signature
- this.logger.logAdapterMethod('append', [options.items, options.eof]);
- this.workflow.call({
- process: AdapterProcess.append,
- status: ProcessStatus.start,
- payload: { options }
- });
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- prepend(_options: AdapterPrependOptions
- | unknown, bof?: boolean): any {
- const options = convertAppendArgs(true, _options, bof); // support old signature
- this.logger.logAdapterMethod('prepend', [options.items, options.bof]);
- this.workflow.call({
- process: AdapterProcess.prepend,
- status: ProcessStatus.start,
- payload: { options }
- });
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- check(): any {
- this.logger.logAdapterMethod('check');
- this.workflow.call({
- process: AdapterProcess.check,
- status: ProcessStatus.start
- });
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- remove(options: AdapterRemoveOptions
- | ItemsPredicate
- ): any {
- options = convertRemoveArgs(options); // support old signature
- this.logger.logAdapterMethod('remove', options);
- this.workflow.call({
- process: AdapterProcess.remove,
- status: ProcessStatus.start,
- payload: { options }
- });
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- clip(options?: AdapterClipOptions): any {
- this.logger.logAdapterMethod('clip', options);
- this.workflow.call({
- process: AdapterProcess.clip,
- status: ProcessStatus.start,
- payload: { options }
- });
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- insert(options: AdapterInsertOptions
- ): any {
- this.logger.logAdapterMethod('insert', options);
- this.workflow.call({
- process: AdapterProcess.insert,
- status: ProcessStatus.start,
- payload: { options }
- });
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- replace(options: AdapterReplaceOptions
- ): any {
- this.logger.logAdapterMethod('replace', options);
- this.workflow.call({
- process: AdapterProcess.replace,
- status: ProcessStatus.start,
- payload: { options }
- });
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- update(options: AdapterUpdateOptions
- ): any {
- this.logger.logAdapterMethod('update', options);
- this.workflow.call({
- process: AdapterProcess.update,
- status: ProcessStatus.start,
- payload: { options }
- });
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- pause(): any {
- this.logger.logAdapterMethod('pause');
- this.workflow.call({
- process: AdapterProcess.pause,
- status: ProcessStatus.start
- });
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- resume(): any {
- this.logger.logAdapterMethod('resume');
- this.workflow.call({
- process: AdapterProcess.pause,
- status: ProcessStatus.start,
- payload: { options: { resume: true } }
- });
- }
-
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- fix(options: AdapterFixOptions
- ): any {
- this.logger.logAdapterMethod('fix', options);
- this.workflow.call({
- process: AdapterProcess.fix,
- status: ProcessStatus.start,
- payload: { options }
- });
- }
-
- relaxUnchained(callback: (() => void) | undefined, reloadId: string): Promise {
- const runCallback = () => typeof callback === 'function' && reloadId === this.reloadId && callback();
- if (!this.isLoading) {
- runCallback();
- }
- return new Promise(resolve => {
- if (!this.isLoading) {
- resolve(true);
- return;
- }
- this.isLoading$.once(() => {
- runCallback();
- resolve(false);
- });
- }).then(immediate => {
- if (this.disposed) {
- return {
- immediate,
- success: false,
- details: 'Adapter was disposed'
- };
- }
- const success = reloadId === this.reloadId;
- this.logger?.log?.(() => !success ? `relax promise cancelled due to ${reloadId} != ${this.reloadId}` : void 0);
- return {
- immediate,
- success,
- details: !success ? 'Interrupted by reload or reset' : null
- };
- });
- }
-
- relax(callback?: () => void): Promise {
- const reloadId = this.reloadId;
- this.logger.logAdapterMethod('relax', callback, ` of ${reloadId}`);
- if (!this.init) {
- return Promise.resolve(methodPreResult);
- }
- return this.relaxRun = this.relaxRun
- ? this.relaxRun.then(() => this.relaxUnchained(callback, reloadId))
- : this.relaxUnchained(callback, reloadId).then((result) => {
- this.relaxRun = null;
- return result;
- });
- }
-
- showLog(): void {
- this.logger.logAdapterMethod('showLog');
- this.logger.logForce();
- }
-}
+import { Logger } from './logger';
+import { Buffer } from './buffer';
+import { Reactive } from './reactive';
+import {
+ AdapterPropName,
+ AdapterPropType,
+ EMPTY_ITEM,
+ getDefaultAdapterProps,
+ methodPausedResult,
+ methodPreResult,
+ reactiveConfigStorage
+} from './adapter/props';
+import { wantedUtils } from './adapter/wanted';
+import { Viewport } from './viewport';
+import { Direction } from '../inputs/index';
+import { AdapterProcess, ProcessStatus } from '../processes/index';
+import {
+ WorkflowGetter,
+ IAdapterProp,
+ AdapterMethodResult,
+ IAdapter,
+ ItemAdapter,
+ ItemsPredicate,
+ AdapterPrependOptions,
+ AdapterAppendOptions,
+ AdapterRemoveOptions,
+ AdapterClipOptions,
+ AdapterInsertOptions,
+ AdapterReplaceOptions,
+ AdapterUpdateOptions,
+ AdapterFixOptions,
+ ScrollerWorkflow,
+ IDatasourceOptional,
+ IPackages,
+ IBufferInfo,
+ State,
+ ProcessSubject
+} from '../interfaces/index';
+
+type MethodResolver = (...args: unknown[]) => Promise;
+type InitializationParams
- = {
+ buffer: Buffer
- ;
+ state: State;
+ viewport: Viewport;
+ logger: Logger;
+ adapterRun$?: Reactive;
+ getWorkflow?: WorkflowGetter
- ;
+};
+
+const ADAPTER_PROPS_STUB = getDefaultAdapterProps();
+const ALLOWED_METHODS_WHEN_PAUSED = ADAPTER_PROPS_STUB.filter(v => !!v.allowedWhenPaused).map(
+ v => v.name
+);
+
+const _has = (obj: unknown, prop: string): boolean =>
+ !!obj && typeof obj === 'object' && Object.prototype.hasOwnProperty.call(obj, prop);
+
+const convertAppendArgs =
- (prepend: boolean, options: unknown, eof?: boolean) => {
+ let result = options as AdapterAppendOptions
- & AdapterPrependOptions
- ;
+ if (!_has(options, 'items')) {
+ const items = !Array.isArray(options) ? [options] : options;
+ result = prepend ? { items, bof: eof } : { items, eof: eof };
+ }
+ return result;
+};
+
+const convertRemoveArgs =
- (options: AdapterRemoveOptions
- | ItemsPredicate
- ) => {
+ if (!(_has(options, 'predicate') || _has(options, 'indexes'))) {
+ const predicate = options as ItemsPredicate
- ;
+ options = { predicate };
+ }
+ return options;
+};
+
+export class Adapter
- implements IAdapter
- {
+ private externalContext: IAdapter
- ;
+ private logger: Logger;
+ private getWorkflow: WorkflowGetter
- ;
+ private reloadCounter: number;
+ private source: { [key: string]: Reactive } = {}; // for Reactive props
+ private box: { [key: string]: unknown } = {}; // for Scalars over Reactive props
+ private demand: { [key: string]: unknown } = {}; // for Scalars on demand
+ private disposed: boolean;
+
+ setFirstOrLastVisible = (_: {
+ first?: boolean;
+ last?: boolean;
+ workflow?: ScrollerWorkflow;
+ }) => {};
+
+ get workflow(): ScrollerWorkflow
- {
+ return this.getWorkflow();
+ }
+ get reloadCount(): number {
+ return this.reloadCounter;
+ }
+ get reloadId(): string {
+ return this.id + '.' + this.reloadCounter;
+ }
+
+ id: number;
+ mock: boolean;
+ augmented: boolean;
+ version: string;
+ init: boolean;
+ init$: Reactive;
+ packageInfo: IPackages;
+ itemsCount: number;
+ bufferInfo: IBufferInfo;
+ isLoading: boolean;
+ isLoading$: Reactive;
+ loopPending: boolean;
+ loopPending$: Reactive;
+ firstVisible: ItemAdapter
- ;
+ firstVisible$: Reactive>;
+ lastVisible: ItemAdapter
- ;
+ lastVisible$: Reactive>;
+ bof: boolean;
+ bof$: Reactive;
+ eof: boolean;
+ eof$: Reactive;
+ paused: boolean;
+ paused$: Reactive;
+
+ private relax$: Reactive | null;
+ private relaxRun: Promise | null;
+
+ private getPromisifiedMethod(method: MethodResolver, args: unknown[]) {
+ return new Promise(resolve => {
+ if (this.relax$) {
+ this.relax$.once(value => resolve(value));
+ }
+ method.apply(this, args);
+ });
+ }
+
+ private getWorkflowRunnerMethod(method: MethodResolver, name: AdapterPropName) {
+ return (...args: unknown[]): Promise => {
+ if (!this.relax$) {
+ this.logger?.log?.(() => 'scroller is not initialized: ' + name + ' method is ignored');
+ return Promise.resolve(methodPreResult);
+ }
+ if (this.paused && !ALLOWED_METHODS_WHEN_PAUSED.includes(name)) {
+ this.logger?.log?.(() => 'scroller is paused: ' + name + ' method is ignored');
+ return Promise.resolve(methodPausedResult);
+ }
+ return this.getPromisifiedMethod(method, args);
+ };
+ }
+
+ constructor(context: IAdapter
- | null, getWorkflow: WorkflowGetter
- , logger: Logger) {
+ this.getWorkflow = getWorkflow;
+ this.logger = logger;
+ this.relax$ = null;
+ this.relaxRun = null;
+ this.reloadCounter = 0;
+ const contextId = context?.id || -1;
+
+ // public context (if exists) should provide access to Reactive props config by id
+ const reactivePropsStore = (context && reactiveConfigStorage.get(context.id)) || {};
+
+ // the Adapter initialization should not trigger "wanted" props setting;
+ // after the initialization is completed, "wanted" functionality must be unblocked
+ wantedUtils.setBlock(true, contextId);
+
+ // make array of the original values from public context if present
+ const adapterProps = context
+ ? ADAPTER_PROPS_STUB.map(prop => {
+ let value = context[prop.name];
+ // if context is augmented, we need to replace external reactive props with inner ones
+ if (context.augmented) {
+ const reactiveProp = reactivePropsStore[prop.name];
+ if (reactiveProp) {
+ value = reactiveProp.default as Reactive; // boolean doesn't matter here
+ }
+ }
+ return { ...prop, value };
+ })
+ : getDefaultAdapterProps();
+
+ // restore default reactive props if they were configured
+ Object.entries(reactivePropsStore).forEach(([key, value]) => {
+ const prop = adapterProps.find(({ name }) => name === key);
+ if (prop && value) {
+ prop.value = value.default;
+ }
+ });
+
+ // Scalar permanent props
+ adapterProps
+ .filter(({ type, permanent }) => type === AdapterPropType.Scalar && permanent)
+ .forEach(({ name, value }: IAdapterProp) =>
+ Object.defineProperty(this, name, {
+ configurable: true,
+ get: () => value
+ })
+ );
+
+ // Reactive props: store original values in "source" container, to avoid extra .get() calls on scalar twins set
+ adapterProps
+ .filter(prop => prop.type === AdapterPropType.Reactive)
+ .forEach(({ name, value }: IAdapterProp) => {
+ this.source[name] = value as Reactive;
+ Object.defineProperty(this, name, {
+ configurable: true,
+ get: () => this.source[name]
+ });
+ });
+
+ // for "wanted" props that can be explicitly requested for the first time after the Adapter initialization,
+ // an implicit calculation of the initial value is required;
+ // so this method should be called when accessing the "wanted" props through one of the following getters
+ const processWanted = (prop: IAdapterProp) => {
+ if (wantedUtils.setBox(prop, contextId)) {
+ const firstPropList = [AdapterPropName.firstVisible, AdapterPropName.firstVisible$];
+ const lastPropList = [AdapterPropName.lastVisible, AdapterPropName.lastVisible$];
+ if (firstPropList.some(n => n === prop.name)) {
+ this.setFirstOrLastVisible({ first: true });
+ } else if (lastPropList.some(n => n === prop.name)) {
+ this.setFirstOrLastVisible({ last: true });
+ }
+ }
+ };
+
+ // Scalar props that have Reactive twins
+ // 1) reactive props (from "source") should be triggered on set
+ // 2) scalars should use "box" container on get
+ // 3) "wanted" scalars should also run wanted-related logic on get
+ adapterProps
+ .filter(prop => prop.type === AdapterPropType.Scalar && !!prop.reactive)
+ .forEach((prop: IAdapterProp) => {
+ const { name, value, reactive } = prop;
+ this.box[name] = value;
+ Object.defineProperty(this, name, {
+ configurable: true,
+ set: (newValue: unknown) => {
+ if (newValue !== this.box[name]) {
+ this.box[name] = newValue;
+ this.source[reactive as AdapterPropName].set(newValue);
+ // need to emit new value through the configured reactive prop if present
+ const reactiveProp = reactivePropsStore[reactive as AdapterPropName];
+ if (reactiveProp) {
+ reactiveProp.emit(reactiveProp.source, newValue);
+ }
+ }
+ },
+ get: () => {
+ processWanted(prop);
+ return this.box[name];
+ }
+ });
+ });
+
+ // Scalar props on-demand
+ // these scalars should use "demand" container
+ // setting defaults should be overridden on init()
+ adapterProps
+ .filter(prop => prop.type === AdapterPropType.Scalar && prop.onDemand)
+ .forEach(({ name, value }: IAdapterProp) => {
+ this.demand[name] = value;
+ Object.defineProperty(this, name, {
+ configurable: true,
+ get: () => this.demand[name]
+ });
+ });
+
+ if (!context) {
+ return;
+ }
+
+ // Adapter public context augmentation
+ adapterProps.forEach((prop: IAdapterProp) => {
+ const { name, type, permanent } = prop;
+ let value = (this as IAdapter)[name];
+ if (type === AdapterPropType.Function) {
+ value = (value as () => void).bind(this);
+ } else if (type === AdapterPropType.WorkflowRunner) {
+ value = this.getWorkflowRunnerMethod(value as MethodResolver, name);
+ } else if (type === AdapterPropType.Reactive && reactivePropsStore[name]) {
+ value = (context as IAdapter)[name];
+ } else if (name === AdapterPropName.augmented) {
+ value = true;
+ }
+ const nonPermanentScalar = !permanent && type === AdapterPropType.Scalar;
+ Object.defineProperty(context, name, {
+ configurable: true,
+ get: () => {
+ processWanted(prop); // consider accessing "wanted" Reactive props
+ if (nonPermanentScalar) {
+ return (this as IAdapter)[name]; // non-permanent Scalars should be taken in runtime
+ }
+ return value; // other props (Reactive/Functions/WorkflowRunners) can be defined once
+ }
+ });
+ });
+
+ this.externalContext = context;
+ wantedUtils.setBlock(false, contextId);
+ }
+
+ initialize({
+ buffer,
+ state,
+ viewport,
+ logger,
+ adapterRun$,
+ getWorkflow
+ }: InitializationParams
- ): void {
+ // buffer
+ Object.defineProperty(this.demand, AdapterPropName.itemsCount, {
+ get: () => buffer.getVisibleItemsCount()
+ });
+ Object.defineProperty(this.demand, AdapterPropName.bufferInfo, {
+ get: (): IBufferInfo => ({
+ firstIndex: buffer.firstIndex,
+ lastIndex: buffer.lastIndex,
+ minIndex: buffer.minIndex,
+ maxIndex: buffer.maxIndex,
+ absMinIndex: buffer.absMinIndex,
+ absMaxIndex: buffer.absMaxIndex,
+ defaultSize: buffer.defaultSize
+ })
+ });
+ this.bof = buffer.bof.get();
+ buffer.bof.on(bof => (this.bof = bof));
+ this.eof = buffer.eof.get();
+ buffer.eof.on(eof => (this.eof = eof));
+
+ // state
+ Object.defineProperty(this.demand, AdapterPropName.packageInfo, {
+ get: () => state.packageInfo
+ });
+ this.loopPending = state.cycle.innerLoop.busy.get();
+ state.cycle.innerLoop.busy.on(busy => (this.loopPending = busy));
+ this.isLoading = state.cycle.busy.get();
+ state.cycle.busy.on(busy => (this.isLoading = busy));
+ this.paused = state.paused.get();
+ state.paused.on(paused => (this.paused = paused));
+
+ //viewport
+ this.setFirstOrLastVisible = ({ first, last, workflow }) => {
+ if ((!first && !last) || workflow?.call?.interrupted) {
+ return;
+ }
+ const token = first ? AdapterPropName.firstVisible : AdapterPropName.lastVisible;
+ if (!wantedUtils.getBox(this.externalContext?.id)?.[token]) {
+ return;
+ }
+ if (buffer.items.some(({ element }) => !element)) {
+ logger.log(
+ 'skipping first/lastVisible set because not all buffered items are rendered at this moment'
+ );
+ return;
+ }
+ const direction = first ? Direction.backward : Direction.forward;
+ const { item } = viewport.getEdgeVisibleItem(buffer.items, direction);
+ if (!item || item.element !== this[token].element) {
+ this[token] = (item ? item.get() : EMPTY_ITEM) as ItemAdapter
- ;
+ }
+ };
+
+ // logger
+ this.logger = logger;
+
+ // self-pending subscription; set up only on the very first init
+ if (adapterRun$) {
+ if (!this.relax$) {
+ this.relax$ = new Reactive();
+ }
+ const relax$ = this.relax$;
+ adapterRun$.on(({ status, payload }) => {
+ let unSubRelax = () => {};
+ if (status === ProcessStatus.start) {
+ unSubRelax = this.isLoading$.on(value => {
+ if (!value) {
+ unSubRelax();
+ relax$.set({ success: true, immediate: false, details: null });
+ }
+ });
+ } else if (status === ProcessStatus.done || status === ProcessStatus.error) {
+ unSubRelax();
+ relax$.set({
+ success: status !== ProcessStatus.error,
+ immediate: true,
+ details: status === ProcessStatus.error && payload ? String(payload.error) : null
+ });
+ }
+ });
+ }
+
+ // workflow getter
+ if (getWorkflow) {
+ this.getWorkflow = getWorkflow;
+ }
+
+ // init
+ this.init = true;
+ }
+
+ dispose(): void {
+ if (this.relax$) {
+ this.relax$.dispose();
+ }
+ if (this.externalContext) {
+ this.resetContext();
+ }
+ Object.getOwnPropertyNames(this).forEach(prop => {
+ delete (this as Record)[prop];
+ });
+ this.disposed = true;
+ }
+
+ resetContext(): void {
+ const reactiveStore = reactiveConfigStorage.get(this.externalContext?.id);
+ ADAPTER_PROPS_STUB.forEach(({ type, permanent, name, value }) => {
+ // assign initial values to non-reactive non-permanent props
+ if (type !== AdapterPropType.Reactive && !permanent) {
+ Object.defineProperty(this.externalContext, name, {
+ configurable: true,
+ get: () => value
+ });
+ }
+ // reset reactive props
+ if (type === AdapterPropType.Reactive && reactiveStore) {
+ const property = reactiveStore[name];
+ if (property) {
+ property.default.reset();
+ property.emit(property.source, property.default.get());
+ }
+ }
+ });
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ reset(options?: IDatasourceOptional): any {
+ this.reloadCounter++;
+ this.logger.logAdapterMethod('reset', options, ` of ${this.reloadId}`);
+ this.workflow.call({
+ process: AdapterProcess.reset,
+ status: ProcessStatus.start,
+ payload: { options }
+ });
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ reload(options?: number | string): any {
+ this.reloadCounter++;
+ this.logger.logAdapterMethod('reload', options, ` of ${this.reloadId}`);
+ this.workflow.call({
+ process: AdapterProcess.reload,
+ status: ProcessStatus.start,
+ payload: { options }
+ });
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ append(_options: AdapterAppendOptions
- | unknown, eof?: boolean): any {
+ const options = convertAppendArgs(false, _options, eof); // support old signature
+ this.logger.logAdapterMethod('append', [options.items, options.eof]);
+ this.workflow.call({
+ process: AdapterProcess.append,
+ status: ProcessStatus.start,
+ payload: { options }
+ });
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ prepend(_options: AdapterPrependOptions
- | unknown, bof?: boolean): any {
+ const options = convertAppendArgs(true, _options, bof); // support old signature
+ this.logger.logAdapterMethod('prepend', [options.items, options.bof]);
+ this.workflow.call({
+ process: AdapterProcess.prepend,
+ status: ProcessStatus.start,
+ payload: { options }
+ });
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ check(): any {
+ this.logger.logAdapterMethod('check');
+ this.workflow.call({
+ process: AdapterProcess.check,
+ status: ProcessStatus.start
+ });
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ remove(options: AdapterRemoveOptions
- | ItemsPredicate
- ): any {
+ options = convertRemoveArgs(options); // support old signature
+ this.logger.logAdapterMethod('remove', options);
+ this.workflow.call({
+ process: AdapterProcess.remove,
+ status: ProcessStatus.start,
+ payload: { options }
+ });
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ clip(options?: AdapterClipOptions): any {
+ this.logger.logAdapterMethod('clip', options);
+ this.workflow.call({
+ process: AdapterProcess.clip,
+ status: ProcessStatus.start,
+ payload: { options }
+ });
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ insert(options: AdapterInsertOptions
- ): any {
+ this.logger.logAdapterMethod('insert', options);
+ this.workflow.call({
+ process: AdapterProcess.insert,
+ status: ProcessStatus.start,
+ payload: { options }
+ });
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ replace(options: AdapterReplaceOptions
- ): any {
+ this.logger.logAdapterMethod('replace', options);
+ this.workflow.call({
+ process: AdapterProcess.replace,
+ status: ProcessStatus.start,
+ payload: { options }
+ });
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ update(options: AdapterUpdateOptions
- ): any {
+ this.logger.logAdapterMethod('update', options);
+ this.workflow.call({
+ process: AdapterProcess.update,
+ status: ProcessStatus.start,
+ payload: { options }
+ });
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ pause(): any {
+ this.logger.logAdapterMethod('pause');
+ this.workflow.call({
+ process: AdapterProcess.pause,
+ status: ProcessStatus.start
+ });
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ resume(): any {
+ this.logger.logAdapterMethod('resume');
+ this.workflow.call({
+ process: AdapterProcess.pause,
+ status: ProcessStatus.start,
+ payload: { options: { resume: true } }
+ });
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ fix(options: AdapterFixOptions
- ): any {
+ this.logger.logAdapterMethod('fix', options);
+ this.workflow.call({
+ process: AdapterProcess.fix,
+ status: ProcessStatus.start,
+ payload: { options }
+ });
+ }
+
+ relaxUnchained(
+ callback: (() => void) | undefined,
+ reloadId: string
+ ): Promise {
+ const runCallback = () =>
+ typeof callback === 'function' && reloadId === this.reloadId && callback();
+ if (!this.isLoading) {
+ runCallback();
+ }
+ return new Promise(resolve => {
+ if (!this.isLoading) {
+ resolve(true);
+ return;
+ }
+ this.isLoading$.once(() => {
+ runCallback();
+ resolve(false);
+ });
+ }).then(immediate => {
+ if (this.disposed) {
+ return {
+ immediate,
+ success: false,
+ details: 'Adapter was disposed'
+ };
+ }
+ const success = reloadId === this.reloadId;
+ this.logger?.log?.(() =>
+ !success ? `relax promise cancelled due to ${reloadId} != ${this.reloadId}` : void 0
+ );
+ return {
+ immediate,
+ success,
+ details: !success ? 'Interrupted by reload or reset' : null
+ };
+ });
+ }
+
+ relax(callback?: () => void): Promise {
+ const reloadId = this.reloadId;
+ this.logger.logAdapterMethod('relax', callback, ` of ${reloadId}`);
+ if (!this.init) {
+ return Promise.resolve(methodPreResult);
+ }
+ return (this.relaxRun = this.relaxRun
+ ? this.relaxRun.then(() => this.relaxUnchained(callback, reloadId))
+ : this.relaxUnchained(callback, reloadId).then(result => {
+ this.relaxRun = null;
+ return result;
+ }));
+ }
+
+ showLog(): void {
+ this.logger.logAdapterMethod('showLog');
+ this.logger.logForce();
+ }
+}
diff --git a/src/classes/adapter/context.ts b/src/classes/adapter/context.ts
index a8717924..8b4e4d78 100644
--- a/src/classes/adapter/context.ts
+++ b/src/classes/adapter/context.ts
@@ -1,4 +1,9 @@
-import { AdapterPropName, AdapterPropType, getDefaultAdapterProps, reactiveConfigStorage } from './props';
+import {
+ AdapterPropName,
+ AdapterPropType,
+ getDefaultAdapterProps,
+ reactiveConfigStorage
+} from './props';
import core from '../../version';
import { Reactive } from '../reactive';
import { wantedStorage, wantedUtils } from './wanted';
@@ -7,7 +12,6 @@ import { IReactivePropsStore, IAdapterConfig } from '../../interfaces/index';
let instanceCount = 0;
export class AdapterContext {
-
constructor(config: IAdapterConfig) {
const { mock, reactive } = config;
const id = ++instanceCount;
@@ -51,7 +55,8 @@ export class AdapterContext {
});
});
- if (reactive) { // save both configured and default reactive props in the store
+ if (reactive) {
+ // save both configured and default reactive props in the store
reactiveConfigStorage.set(id, reactivePropsStore);
}
}
diff --git a/src/classes/adapter/props.ts b/src/classes/adapter/props.ts
index db888a6a..a5328ffa 100644
--- a/src/classes/adapter/props.ts
+++ b/src/classes/adapter/props.ts
@@ -1,6 +1,11 @@
import { Reactive } from '../reactive';
import {
- IAdapterProp, IBufferInfo, ItemAdapter, IPackages, AdapterMethodResult, IReactivePropsStore
+ IAdapterProp,
+ IBufferInfo,
+ ItemAdapter,
+ IPackages,
+ AdapterMethodResult,
+ IReactivePropsStore
} from '../../interfaces/index';
export enum AdapterPropName {
@@ -41,14 +46,14 @@ export enum AdapterPropName {
resume = 'resume',
fix = 'fix',
relax = 'relax',
- showLog = 'showLog',
+ showLog = 'showLog'
}
export enum AdapterPropType {
Scalar,
Reactive,
WorkflowRunner,
- Function,
+ Function
}
const Name = AdapterPropName;
@@ -88,7 +93,7 @@ const bufferInfoDefault: IBufferInfo = {
maxIndex: NaN,
absMinIndex: -Infinity,
absMaxIndex: +Infinity,
- defaultSize: NaN,
+ defaultSize: NaN
};
export const EMPTY_ITEM = {
diff --git a/src/classes/buffer.ts b/src/classes/buffer.ts
index 850c0e31..58ec3521 100644
--- a/src/classes/buffer.ts
+++ b/src/classes/buffer.ts
@@ -8,7 +8,6 @@ import { Direction } from '../inputs/index';
import { OnDataChanged, BufferUpdater, ItemsPredicate } from '../interfaces/index';
export class Buffer {
-
private _items: Item[] = [];
private _absMinIndex: number;
private _absMaxIndex: number;
@@ -69,11 +68,15 @@ export class Buffer {
index = start;
}
if (index < min) {
- this.logger.log(() => `setting startIndex to settings.minIndex (${min}) because ${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}`);
+ this.logger.log(
+ () => `setting startIndex to settings.maxIndex (${max}) because ${index} > ${max}`
+ );
index = max;
}
this.startIndex = index;
@@ -94,7 +97,8 @@ export class Buffer {
set absMinIndex(value: number) {
if (this._absMinIndex !== value) {
- this._absMinIndex = Number.isFinite(this._absMaxIndex) && value > this._absMaxIndex ? this._absMaxIndex : value;
+ this._absMinIndex =
+ Number.isFinite(this._absMaxIndex) && value > this._absMaxIndex ? this._absMaxIndex : value;
}
if (!this.pristine) {
this.checkBOF();
@@ -107,7 +111,8 @@ export class Buffer {
set absMaxIndex(value: number) {
if (this._absMaxIndex !== value) {
- this._absMaxIndex = Number.isFinite(this._absMinIndex) && value < this._absMinIndex ? this._absMinIndex : value;
+ this._absMaxIndex =
+ Number.isFinite(this._absMinIndex) && value < this._absMinIndex ? this._absMinIndex : value;
}
if (!this.pristine) {
this.checkEOF();
@@ -121,7 +126,7 @@ export class Buffer {
private checkBOF() {
// since bof has no setter, need to call checkBOF() on items and absMinIndex change
const bof = this.items.length
- ? (this.items[0].$index === this.absMinIndex)
+ ? this.items[0].$index === this.absMinIndex
: isFinite(this.absMinIndex);
this.bof.set(bof);
}
@@ -129,7 +134,7 @@ export class Buffer {
private checkEOF() {
// since eof has no setter, need to call checkEOF() on items and absMaxIndex change
const eof = this.items.length
- ? (this.items[this.items.length - 1].$index === this.absMaxIndex)
+ ? this.items[this.items.length - 1].$index === this.absMaxIndex
: isFinite(this.absMaxIndex);
this.eof.set(eof);
}
@@ -231,16 +236,13 @@ export class Buffer {
removeVirtually(indexes: number[], fixRight: boolean): void {
const length = this.items.length;
let shifted = false;
- for (
- let i = fixRight ? length - 1 : 0;
- fixRight ? i >= 0 : i < length;
- fixRight ? i-- : i++
- ) {
+ for (let i = fixRight ? length - 1 : 0; fixRight ? i >= 0 : i < length; fixRight ? i-- : i++) {
const item = this.items[i];
- const diff = indexes.reduce((acc, index) => acc + (fixRight
- ? (item.$index < index ? 1 : 0)
- : (item.$index > index ? -1 : 0)
- ), 0);
+ const diff = indexes.reduce(
+ (acc, index) =>
+ acc + (fixRight ? (item.$index < index ? 1 : 0) : item.$index > index ? -1 : 0),
+ 0
+ );
shifted = shifted || !!diff;
item.updateIndex(item.$index + diff);
}
@@ -252,18 +254,19 @@ export class Buffer {
}
fillEmpty(
- items: Data[], beforeIndex: number | undefined, afterIndex: number | undefined, fixRight: boolean,
- generator: (index: number, data: Data) => Item,
+ items: Data[],
+ beforeIndex: number | undefined,
+ afterIndex: number | undefined,
+ fixRight: boolean,
+ generator: (index: number, data: Data) => Item
): boolean {
if (!this.checkCall.fillEmpty(items, beforeIndex, afterIndex)) {
return false;
}
const before = Number.isInteger(beforeIndex);
const index = (before ? beforeIndex : afterIndex) as number;
- const shift = (fixRight ? items.length : (before ? 1 : 0));
- this.items = items.map((data, i) =>
- generator(index + i + (!before ? 1 : 0) - shift, data)
- );
+ const shift = fixRight ? items.length : before ? 1 : 0;
+ this.items = items.map((data, i) => generator(index + i + (!before ? 1 : 0) - shift, data));
this._absMinIndex = this.items[0].$index;
this._absMaxIndex = this.items[this.size - 1].$index;
if (this.startIndex <= this.absMinIndex) {
@@ -279,7 +282,7 @@ export class Buffer {
generator: (index: number, data: Data) => Item,
indexToTrack: number,
fixRight: boolean
- ): { trackedIndex: number, toRemove: Item[] } {
+ ): { trackedIndex: number; toRemove: Item[] } {
if (!this.size || Number.isNaN(this.firstIndex)) {
return { trackedIndex: NaN, toRemove: [] };
}
@@ -299,7 +302,7 @@ export class Buffer {
// if predicate result is falsy or empty array -> delete
if (!result || (Array.isArray(result) && !result.length)) {
item.toRemove = true;
- trackedIndex += item.$index >= indexToTrack ? (fixRight ? 1 : 0) : (fixRight ? 0 : -1);
+ trackedIndex += item.$index >= indexToTrack ? (fixRight ? 1 : 0) : fixRight ? 0 : -1;
this.shiftExtremum(-1, fixRight);
continue;
}
@@ -394,8 +397,9 @@ export class Buffer {
}
getEdgeVisibleItem(direction: Direction, opposite?: boolean): Item | undefined {
- return direction === (!opposite ? Direction.forward : Direction.backward) ?
- this.getLastVisibleItem() : this.getFirstVisibleItem();
+ return direction === (!opposite ? Direction.forward : Direction.backward)
+ ? this.getLastVisibleItem()
+ : this.getFirstVisibleItem();
}
getVisibleItemsCount(): number {
@@ -409,5 +413,4 @@ export class Buffer {
checkDefaultSize(): boolean {
return this.cache.recalculateDefaultSize();
}
-
}
diff --git a/src/classes/buffer/cache.ts b/src/classes/buffer/cache.ts
index cd5a78b9..d392fe2f 100644
--- a/src/classes/buffer/cache.ts
+++ b/src/classes/buffer/cache.ts
@@ -76,7 +76,7 @@ export class Cache {
getSizeByIndex(index: number): number {
const item = this.get(index);
- return item && item.size || this.defaultSize.get();
+ return (item && item.size) || this.defaultSize.get();
}
getDefaultSize(): number {
@@ -96,12 +96,12 @@ export class Cache {
* Maintains min/max indexes and default item size.
*
* @param {Item} item A Buffer item to be cached, an objects with { $index, data, size } props.
- *
* @returns {ItemCache} Cached item.
*/
add(item: Item): ItemCache {
let itemCache = this.get(item.$index);
- if (itemCache) { // adding item is already cached
+ if (itemCache) {
+ // adding item is already cached
if (this.saveData) {
itemCache.data = item.data;
}
@@ -142,7 +142,8 @@ export class Cache {
insertItems(toInsert: Data[], index: number, direction: Direction, fixRight: boolean): void {
const items = new Map>();
const length = toInsert.length;
- let min = Infinity, max = -Infinity;
+ let min = Infinity,
+ max = -Infinity;
const set = (item: ItemCache) => {
items.set(item.$index, item);
min = item.$index < min ? item.$index : min;
@@ -168,9 +169,11 @@ export class Cache {
}
set(item);
});
- if (this.saveData) { // persist data with no sizes
+ if (this.saveData) {
+ // persist data with no sizes
toInsert.forEach((data, i) => {
- const $index = index + i - (fixRight ? length : 0) + (direction === Direction.forward ? 1 : 0);
+ const $index =
+ index + i - (fixRight ? length : 0) + (direction === Direction.forward ? 1 : 0);
const item = new ItemCache({ $index, data }, this.saveData);
set(item);
});
@@ -192,7 +195,8 @@ export class Cache {
*/
removeItems(toRemove: number[], fixRight: boolean): void {
const items = new Map>();
- let min = Infinity, max = -Infinity;
+ let min = Infinity,
+ max = -Infinity;
this.items.forEach(item => {
if (toRemove.some(index => index === item.$index)) {
if (item.size) {
@@ -229,10 +233,12 @@ export class Cache {
if (!this.size || !before.length) {
return;
}
- const minB = before[0].$index, maxB = before[before.length - 1].$index;
+ const minB = before[0].$index,
+ maxB = before[before.length - 1].$index;
let leftDiff: number, rightDiff: number;
if (after.length) {
- const minA = after[0].$index, maxA = after[after.length - 1].$index;
+ const minA = after[0].$index,
+ maxA = after[after.length - 1].$index;
leftDiff = minA - minB;
rightDiff = maxA - maxB;
} else {
@@ -241,18 +247,22 @@ export class Cache {
}
const items = new Map>();
this.items.forEach(item => {
- if (item.$index < minB) { // items to the left of the subset
+ if (item.$index < minB) {
+ // items to the left of the subset
item.changeIndex(item.$index + leftDiff);
items.set(item.$index, item);
return;
- } else if (item.$index > maxB) { // items to the right of the subset
+ } else if (item.$index > maxB) {
+ // items to the right of the subset
item.changeIndex(item.$index + rightDiff);
items.set(item.$index, item);
return;
}
});
- after.forEach(item => // subset items
- items.set(item.$index, new ItemCache(item, this.saveData))
+ after.forEach(
+ (
+ item // subset items
+ ) => items.set(item.$index, new ItemCache(item, this.saveData))
);
before // to maintain default size on remove
.filter(item => item.toRemove)
@@ -271,7 +281,8 @@ export class Cache {
*/
shiftIndexes(delta: number): void {
const items = new Map>();
- let min = Infinity, max = -Infinity;
+ let min = Infinity,
+ max = -Infinity;
this.items.forEach(item => {
item.changeIndex(item.$index + delta);
items.set(item.$index, item);
diff --git a/src/classes/buffer/checkCall.ts b/src/classes/buffer/checkCall.ts
index 695a3fc1..35ccbeed 100644
--- a/src/classes/buffer/checkCall.ts
+++ b/src/classes/buffer/checkCall.ts
@@ -26,13 +26,13 @@ export class CheckBufferCall {
}
insertInBuffer(predicate?: ItemsPredicate, before?: number, after?: number): number {
- const index = Number.isInteger(before) ? before : (Number.isInteger(after) ? after : NaN);
- const found = this.context.items.find(item =>
- (predicate && predicate(item.get())) ||
- (Number.isInteger(index) && index === item.$index)
+ const index = Number.isInteger(before) ? before : Number.isInteger(after) ? after : NaN;
+ const found = this.context.items.find(
+ item =>
+ (predicate && predicate(item.get())) || (Number.isInteger(index) && index === item.$index)
);
if (!found) {
- this.logger.log('no items to insert in buffer; empty predicate\'s result');
+ this.logger.log('no items to insert in buffer; empty predicate result');
return NaN;
}
return found.$index;
@@ -45,15 +45,16 @@ export class CheckBufferCall {
}
const { firstIndex, lastIndex, finiteAbsMinIndex, finiteAbsMaxIndex } = this.context;
if (index < finiteAbsMinIndex || index > finiteAbsMaxIndex) {
- this.logger.log(() =>
- 'no items to insert virtually; ' +
- `selected index (${index}) does not match virtual area [${finiteAbsMinIndex}..${finiteAbsMaxIndex}]`
+ this.logger.log(
+ () =>
+ 'no items to insert virtually; ' +
+ `selected index (${index}) does not match virtual area [${finiteAbsMinIndex}..${finiteAbsMaxIndex}]`
);
return false;
}
const before = direction === Direction.backward;
if (!(index < firstIndex + (before ? 1 : 0) || index > lastIndex - (before ? 0 : 1))) {
- this.logger.log(() =>
+ this.logger.log(
`no items to insert virtually; selected index (${index}) belongs Buffer [${firstIndex}..${lastIndex}]`
);
return false;
@@ -61,5 +62,4 @@ export class CheckBufferCall {
this.logger.log(() => `going to insert ${items.length} item(s) virtually`);
return true;
}
-
}
diff --git a/src/classes/buffer/defaultSize.ts b/src/classes/buffer/defaultSize.ts
index 7c5f3c1c..3b9d74fe 100644
--- a/src/classes/buffer/defaultSize.ts
+++ b/src/classes/buffer/defaultSize.ts
@@ -77,7 +77,8 @@ export class DefaultSize {
if (removed.length) {
const removedSize = removed.reduce((acc, item) => acc + item.size, 0);
const averageSize = this.averageSizeFloat || 0;
- this.averageSizeFloat = ((cacheSize + removed.length) * averageSize - removedSize) / cacheSize;
+ this.averageSizeFloat =
+ ((cacheSize + removed.length) * averageSize - removedSize) / cacheSize;
}
this.averageSize = Math.round(this.averageSizeFloat);
}
@@ -89,11 +90,17 @@ export class DefaultSize {
newItems.forEach(({ size }) => this.sizeMap.set(size, (this.sizeMap.get(size) || 0) + 1));
}
if (oldItems.length) {
- oldItems.forEach(({ size }) => this.sizeMap.set(size, Math.max((this.sizeMap.get(size) || 0) - 1, 0)));
- oldItems.forEach(({ newSize: s }) => this.sizeMap.set(s as number, (this.sizeMap.get(s as number) || 0) + 1));
+ oldItems.forEach(({ size }) =>
+ this.sizeMap.set(size, Math.max((this.sizeMap.get(size) || 0) - 1, 0))
+ );
+ oldItems.forEach(({ newSize: s }) =>
+ this.sizeMap.set(s as number, (this.sizeMap.get(s as number) || 0) + 1)
+ );
}
if (removed.length) {
- removed.forEach(({ size }) => this.sizeMap.set(size, Math.max((this.sizeMap.get(size) || 0) - 1, 0)));
+ removed.forEach(({ size }) =>
+ this.sizeMap.set(size, Math.max((this.sizeMap.get(size) || 0) - 1, 0))
+ );
}
const sorted = [...this.sizeMap.entries()].sort((a, b) => b[1] - a[1]);
const mostFrequentCount = sorted[0][1];
diff --git a/src/classes/datasource.ts b/src/classes/datasource.ts
index 80bf52e6..e890b277 100644
--- a/src/classes/datasource.ts
+++ b/src/classes/datasource.ts
@@ -1,45 +1,65 @@
-import { AdapterContext } from './adapter/context';
-import { reactiveConfigStorage } from './adapter/props';
-import { wantedStorage } from './adapter/wanted';
-import {
- IDatasourceParams,
- IDatasourceConstructed,
- DatasourceGet,
- Settings,
- DevSettings,
- IAdapter,
- IAdapterConfig,
-} from '../interfaces/index';
-
-export class DatasourceGeneric implements IDatasourceConstructed {
- get: DatasourceGet;
- settings?: Settings;
- devSettings?: DevSettings;
- adapter: IAdapter;
-
- constructor(datasource: IDatasourceParams, config?: IAdapterConfig) {
- this.get = datasource.get;
- this.settings = datasource.settings;
- this.devSettings = datasource.devSettings;
- const adapterContext = new AdapterContext(config || { mock: false });
- this.adapter = adapterContext as unknown as IAdapter;
- }
-
- dispose(): void { // todo: should it be published?
- reactiveConfigStorage.delete(this.adapter.id);
- wantedStorage.delete(this.adapter.id);
- }
-}
-
-
-export const makeDatasource = (
- getConfig?: () => IAdapterConfig
-) =>
- class extends DatasourceGeneric {
- constructor(datasource: IDatasourceParams) {
- const config = typeof getConfig === 'function' ? getConfig() : void 0;
- super(datasource, config);
- }
- } as DSClassType;
-
-export const Datasource = makeDatasource();
+import { AdapterContext } from './adapter/context';
+import { reactiveConfigStorage, AdapterPropType, getDefaultAdapterProps } from './adapter/props';
+import { wantedStorage } from './adapter/wanted';
+import { Reactive } from './reactive';
+import {
+ IDatasourceParams,
+ IDatasourceConstructed,
+ DatasourceGet,
+ Settings,
+ DevSettings,
+ IAdapter,
+ IAdapterConfig,
+ IReactivePropConfig
+} from '../interfaces/index';
+
+const getDefaultAdapterConfig = (): IAdapterConfig => {
+ const reactive = getDefaultAdapterProps()
+ .filter(({ type }) => type === AdapterPropType.Reactive)
+ .reduce(
+ (acc, { name, value }) => {
+ acc[name] = {
+ source: value,
+ emit: (source, val) => (source as Reactive).set(val)
+ };
+ return acc;
+ },
+ {} as Record
+ );
+
+ return { mock: false, reactive };
+};
+
+export class DatasourceGeneric implements IDatasourceConstructed {
+ get: DatasourceGet;
+ settings?: Settings;
+ devSettings?: DevSettings;
+ adapter: IAdapter;
+
+ constructor(datasource: IDatasourceParams, config?: IAdapterConfig) {
+ this.get = datasource.get;
+ this.settings = datasource.settings;
+ this.devSettings = datasource.devSettings;
+ const adapterContext = new AdapterContext(config || { mock: false });
+ this.adapter = adapterContext as unknown as IAdapter;
+ }
+
+ // todo: should it be published?
+ dispose(): void {
+ reactiveConfigStorage.delete(this.adapter.id);
+ wantedStorage.delete(this.adapter.id);
+ }
+}
+
+export const makeDatasource = (
+ getAdapterConfig?: () => IAdapterConfig
+) =>
+ class extends DatasourceGeneric {
+ constructor(datasource: IDatasourceParams) {
+ const config =
+ typeof getAdapterConfig === 'function' ? getAdapterConfig() : getDefaultAdapterConfig();
+ super(datasource, config);
+ }
+ } as DSClassType;
+
+export const Datasource = makeDatasource();
diff --git a/src/classes/domRoutines.ts b/src/classes/domRoutines.ts
index 0548c033..c8bf9a9f 100644
--- a/src/classes/domRoutines.ts
+++ b/src/classes/domRoutines.ts
@@ -3,7 +3,6 @@ import { Direction } from '../inputs/index';
import { IRoutines, ItemAdapter } from '../interfaces/index';
export class Routines implements IRoutines {
-
readonly settings: IRoutines['settings'];
readonly element: HTMLElement;
readonly viewport: HTMLElement;
@@ -93,17 +92,18 @@ export class Routines implements IRoutines {
}
getWindowParams(): DOMRect {
- const { clientWidth, clientHeight, clientLeft, clientTop } = this.viewport;
+ const height = window.innerHeight;
+ const width = window.innerWidth;
return {
- 'height': clientHeight,
- 'width': clientWidth,
- 'top': clientTop,
- 'bottom': clientTop + clientHeight,
- 'left': clientLeft,
- 'right': clientLeft + clientWidth,
- 'x': clientLeft,
- 'y': clientTop,
- 'toJSON': () => null,
+ height: height,
+ width: width,
+ top: 0,
+ bottom: height,
+ left: 0,
+ right: width,
+ x: 0,
+ y: 0,
+ toJSON: () => null
};
}
@@ -138,7 +138,7 @@ export class Routines implements IRoutines {
const { horizontal } = this.settings;
const params = this.getElementParams(element);
const isFwd = direction === Direction.forward;
- return params[isFwd ? (horizontal ? 'right' : 'bottom') : (horizontal ? 'left' : 'top')];
+ return params[isFwd ? (horizontal ? 'right' : 'bottom') : horizontal ? 'left' : 'top'];
}
getViewportEdge(direction: Direction): number {
@@ -146,7 +146,7 @@ export class Routines implements IRoutines {
if (window) {
const params = this.getWindowParams();
const isFwd = direction === Direction.forward;
- return params[isFwd ? (horizontal ? 'right' : 'bottom') : (horizontal ? 'left' : 'top')];
+ return params[isFwd ? (horizontal ? 'right' : 'bottom') : horizontal ? 'left' : 'top'];
}
return this.getEdge(this.viewport, direction);
}
@@ -174,8 +174,7 @@ export class Routines implements IRoutines {
element.scrollIntoView(argument);
}
- // eslint-disable-next-line @typescript-eslint/no-unused-vars
- render(cb: () => void, params: { items: ItemAdapter[] }): () => void {
+ render(cb: () => void, _params: { items: ItemAdapter[] }): () => void {
const timeoutId = setTimeout(() => cb());
return () => clearTimeout(timeoutId);
}
@@ -190,5 +189,4 @@ export class Routines implements IRoutines {
eventReceiver.addEventListener('scroll', handler);
return () => eventReceiver.removeEventListener('scroll', handler);
}
-
}
diff --git a/src/classes/logger.ts b/src/classes/logger.ts
index a94abf24..e09b174c 100644
--- a/src/classes/logger.ts
+++ b/src/classes/logger.ts
@@ -5,10 +5,10 @@ import { IPackages, ProcessSubject } from '../interfaces/index';
type LogType = [unknown?, ...unknown[]];
export class Logger {
-
readonly debug: boolean;
readonly immediateLog: boolean;
readonly logTime: boolean;
+ readonly logColor: boolean;
readonly getTime: () => string;
readonly getStat: () => string;
readonly getFetchRange: () => string;
@@ -16,44 +16,61 @@ export class Logger {
readonly getLoopId: () => string;
readonly getLoopIdNext: () => string;
readonly getScrollPosition: () => number;
- private logs: unknown[][] = [];
+ private logs: LogType[] = [];
constructor(scroller: Scroller, packageInfo: IPackages, adapter?: { id: number }) {
const { settings } = scroller;
this.debug = settings.debug;
this.immediateLog = settings.immediateLog;
this.logTime = settings.logTime;
- this.getTime = (): string =>
- scroller.state && ` // time: ${scroller.state.time}`;
+ this.logColor = settings.logColor;
+ this.getTime = (): string => scroller.state && ` // time: ${scroller.state.time}`;
this.getStat = (): string => {
const { buffer, viewport } = scroller;
const first = buffer.getFirstVisibleItem();
const last = buffer.getLastVisibleItem();
- return 'pos: ' + viewport.scrollPosition + ', ' +
- 'size: ' + viewport.getScrollableSize() + ', ' +
- 'bwd_p: ' + viewport.paddings.backward.size + ', ' +
- 'fwd_p: ' + viewport.paddings.forward.size + ', ' +
- 'default: ' + (buffer.defaultSize || 'no') + ', ' +
- 'items: ' + buffer.getVisibleItemsCount() + ', ' +
- 'range: ' + (first && last ? `[${first.$index}..${last.$index}]` : 'no');
+ return (
+ 'pos: ' +
+ viewport.scrollPosition +
+ ', ' +
+ 'size: ' +
+ viewport.getScrollableSize() +
+ ', ' +
+ 'bwd_p: ' +
+ viewport.paddings.backward.size +
+ ', ' +
+ 'fwd_p: ' +
+ viewport.paddings.forward.size +
+ ', ' +
+ 'default: ' +
+ (buffer.defaultSize || 'no') +
+ ', ' +
+ 'items: ' +
+ buffer.getVisibleItemsCount() +
+ ', ' +
+ 'range: ' +
+ (first && last ? `[${first.$index}..${last.$index}]` : 'no')
+ );
};
this.getFetchRange = (): string => {
- const { first: { index: first }, last: { index: last } } = scroller.state.fetch;
- return !Number.isNaN(first) && !Number.isNaN(last)
- ? `[${first}..${last}]`
- : 'no';
+ const {
+ first: { index: first },
+ last: { index: last }
+ } = scroller.state.fetch;
+ return !Number.isNaN(first) && !Number.isNaN(last) ? `[${first}..${last}]` : 'no';
};
this.getLoopId = (): string => scroller.state.cycle.loopId;
this.getLoopIdNext = (): string => scroller.state.cycle.loopIdNext;
this.getWorkflowCycleData = (): string =>
`${settings.instanceIndex}-${scroller.state.cycle.count}`;
this.getScrollPosition = () => scroller.routines.getScrollPosition();
- this.log(() =>
- 'vscroll Workflow has been started, ' +
- `core: ${packageInfo.core.name} v${packageInfo.core.version}, ` +
- `consumer: ${packageInfo.consumer.name} v${packageInfo.consumer.version}, ` +
- `scroller instance: ${settings.instanceIndex}, adapter ` +
- (!adapter ? 'is not instantiated' : `instance: ${adapter.id}`)
+ this.log(
+ () =>
+ 'vscroll Workflow has been started, ' +
+ `core: ${packageInfo.core.name} v${packageInfo.core.version}, ` +
+ `consumer: ${packageInfo.consumer.name} v${packageInfo.consumer.version}, ` +
+ `scroller instance: ${settings.instanceIndex}, adapter ` +
+ (!adapter ? 'is not instantiated' : `instance: ${adapter.id}`)
);
}
@@ -61,56 +78,62 @@ export class Logger {
this.log(() => [
str,
stringify
- ? JSON.stringify(obj, (k, v) => {
- if (Number.isNaN(v)) {
- return 'NaN';
- }
- if (v === Infinity) {
- return 'Infinity';
- }
- if (v === -Infinity) {
- return '-Infinity';
- }
- if (v instanceof Element) {
- return 'HTMLElement';
- }
- if (v instanceof HTMLDocument) {
- return 'HTMLDocument';
- }
- if (typeof v === 'function') {
- return 'Function';
- }
- return v;
- })
- .replace(/"/g, '')
- .replace(/(\{|:|,)/g, '$1 ')
- .replace(/(\})/g, ' $1')
+ ? JSON.stringify(obj, (_, v) => {
+ if (Number.isNaN(v)) {
+ return 'NaN';
+ }
+ if (v === Infinity) {
+ return 'Infinity';
+ }
+ if (v === -Infinity) {
+ return '-Infinity';
+ }
+ if (v instanceof Element) {
+ return 'HTMLElement';
+ }
+ if (v instanceof HTMLDocument) {
+ return 'HTMLDocument';
+ }
+ if (typeof v === 'function') {
+ return 'Function';
+ }
+ return v;
+ })
+ .replace(/"/g, '')
+ .replace(/(\{|:|,)/g, '$1 ')
+ .replace(/(\})/g, ' $1')
: obj
]);
}
stat(str?: string): void {
if (this.debug) {
- const logStyles = [
- 'color: #888; border: dashed #888 0; border-bottom-width: 0px',
- 'color: #000; border-width: 0'
- ];
- this.log(() => ['%cstat' + (str ? ` ${str}` : '') + ',%c ' + this.getStat(), ...logStyles]);
+ if (this.logColor) {
+ const logStyles = [
+ 'color: #888; border: dashed #888 0; border-bottom-width: 0px',
+ 'color: #000; border-width: 0'
+ ];
+ this.log(() => ['%cstat' + (str ? ` ${str}` : '') + ',%c ' + this.getStat(), ...logStyles]);
+ } else {
+ this.log(() => ['stat' + (str ? ` ${str}` : '') + ', ' + this.getStat()]);
+ }
}
}
fetch(str?: string): void {
if (this.debug) {
const _text = 'fetch interval' + (str ? ` ${str}` : '');
- const logStyles = ['color: #888', 'color: #000'];
- this.log(() => [`%c${_text}: %c${this.getFetchRange()}`, ...logStyles]);
+ if (this.logColor) {
+ const logStyles = ['color: #888', 'color: #000'];
+ this.log(() => [`%c${_text}: %c${this.getFetchRange()}`, ...logStyles]);
+ } else {
+ this.log(() => [`${_text}: ${this.getFetchRange()}`]);
+ }
}
}
prepareForLog(data: unknown): unknown {
- return data instanceof Event && data.target
- ? this.getScrollPosition()
- : data;
+ return data instanceof Event && data.target ? this.getScrollPosition() : data;
}
logProcess(data: ProcessSubject): void {
@@ -121,35 +144,51 @@ export class Logger {
// inner loop start-end log
const loopLog: string[] = [];
- if (
- process === CommonProcess.init && status === Status.next
- ) {
- loopLog.push(`%c---=== loop ${this.getLoopIdNext()} start`);
- } else if (
- process === CommonProcess.end
- ) {
- loopLog.push(`%c---=== loop ${this.getLoopId()} done`);
+ if (process === CommonProcess.init && status === Status.next) {
+ const loopStart = `---=== loop ${this.getLoopIdNext()} start`;
+ loopLog.push(this.logColor ? `%c${loopStart}` : loopStart);
+ } else if (process === CommonProcess.end) {
+ const loopDone = `---=== loop ${this.getLoopId()} done`;
+ loopLog.push(this.logColor ? `%c${loopDone}` : loopDone);
const parent = payload && payload.process;
- if (status === Status.next && (parent !== AdapterProcess.reset && parent !== AdapterProcess.reload)) {
+ if (
+ status === Status.next &&
+ parent !== AdapterProcess.reset &&
+ parent !== AdapterProcess.reload
+ ) {
loopLog[0] += `, loop ${this.getLoopIdNext()} start`;
}
}
if (loopLog.length) {
- this.log(() => [...loopLog, 'color: #006600;']);
+ this.log(() => (this.logColor ? [...loopLog, 'color: #006600;'] : loopLog));
}
}
logCycle(start = true): void {
const logData = this.getWorkflowCycleData();
- const border = start ? '1px 0 0 1px' : '0 0 1px 1px';
- const logStyles = `color: #0000aa; border: solid #555 1px; border-width: ${border}; margin-left: -2px`;
- this.log(() => [`%c ~~~ WF Cycle ${logData} ${start ? 'STARTED' : 'FINALIZED'} ~~~ `, logStyles]);
+ if (this.logColor) {
+ const border = start ? '1px 0 0 1px' : '0 0 1px 1px';
+ const logStyles = `color: #0000aa; border: solid #555 1px; border-width: ${border}; margin-left: -2px`;
+ this.log(() => [
+ `%c ~~~ WF Cycle ${logData} ${start ? 'STARTED' : 'FINALIZED'} ~~~ `,
+ logStyles
+ ]);
+ } else {
+ this.log(() => [` ~~~ WF Cycle ${logData} ${start ? 'STARTED' : 'FINALIZED'} ~~~ `]);
+ }
}
logError(str: string): void {
if (this.debug) {
- const logStyles = ['color: #a00;', 'color: #000'];
- this.log(() => ['error:%c' + (str ? ` ${str}` : '') + `%c (loop ${this.getLoopIdNext()})`, ...logStyles]);
+ if (this.logColor) {
+ const logStyles = ['color: #a00;', 'color: #000'];
+ this.log(() => [
+ 'error:%c' + (str ? ` ${str}` : '') + `%c (loop ${this.getLoopIdNext()})`,
+ ...logStyles
+ ]);
+ } else {
+ this.log(() => ['error:' + (str ? ` ${str}` : '') + ` (loop ${this.getLoopIdNext()})`]);
+ }
}
}
@@ -157,9 +196,7 @@ export class Logger {
if (!this.debug) {
return;
}
- const params = (
- args === void 0 ? [] : (Array.isArray(args) ? args : [args])
- )
+ const params = (args === void 0 ? [] : Array.isArray(args) ? args : [args])
.map((arg: unknown) => {
if (typeof arg === 'function') {
return 'func';
@@ -218,4 +255,8 @@ export class Logger {
}
}
}
+
+ getLogs(): LogType[] {
+ return this.logs;
+ }
}
diff --git a/src/classes/paddings.ts b/src/classes/paddings.ts
index 380a3aa1..e087582c 100644
--- a/src/classes/paddings.ts
+++ b/src/classes/paddings.ts
@@ -1,93 +1,94 @@
-import { Routines } from './domRoutines';
-import { Settings } from './settings';
-import { Direction } from '../inputs/index';
-
-export class Padding {
-
- element: HTMLElement;
- direction: Direction;
- routines: Routines;
-
- constructor(direction: Direction, routines: Routines) {
- const found = routines.findPaddingElement(direction);
- routines.checkElement(found as HTMLElement);
- this.element = found as HTMLElement;
- this.direction = direction;
- this.routines = routines;
- }
-
- reset(size?: number): void {
- this.size = size || 0;
- }
-
- get size(): number {
- return this.routines.getSizeStyle(this.element);
- }
-
- set size(value: number) {
- this.routines.setSizeStyle(this.element, value);
- }
-
-}
-
-export class Paddings {
- settings: Settings;
- forward: Padding;
- backward: Padding;
-
- constructor(routines: Routines, settings: Settings) {
- this.settings = settings;
- this.forward = new Padding(Direction.forward, routines);
- this.backward = new Padding(Direction.backward, routines);
- }
-
- byDirection(direction: Direction, opposite?: boolean): Padding {
- return direction === Direction.backward
- ? (opposite ? this.forward : this.backward)
- : (opposite ? this.backward : this.forward);
- }
-
- reset(viewportSize: number, startIndex: number, offset: number): void {
- const positive = this.getPositiveSize(startIndex, viewportSize, offset);
- const negative = this.getNegativeSize(startIndex);
- if (this.settings.inverse) {
- this.forward.reset(negative);
- this.backward.reset(positive);
- const diff = viewportSize - this.backward.size - offset;
- if (diff > 0) {
- this.backward.size += diff;
- this.forward.size -= diff;
- }
- } else {
- this.forward.reset(positive);
- this.backward.reset(negative);
- const diff = viewportSize - this.forward.size - offset;
- if (diff > 0) {
- this.backward.size -= diff;
- this.forward.size += diff;
- }
- }
-
- }
-
- getPositiveSize(startIndex: number, viewportSize: number, offset: number): number {
- const { settings } = this;
- let positiveSize = viewportSize;
- if (isFinite(settings.maxIndex)) {
- positiveSize = (settings.maxIndex - startIndex + 1) * settings.itemSize;
- }
- if (offset) {
- positiveSize = Math.max(positiveSize - offset, 0);
- }
- return positiveSize;
- }
-
- getNegativeSize(startIndex: number): number {
- const { settings } = this;
- let negativeSize = 0;
- if (isFinite(settings.minIndex)) {
- negativeSize = (startIndex - settings.minIndex) * settings.itemSize;
- }
- return negativeSize;
- }
-}
+import { Routines } from './domRoutines';
+import { Settings } from './settings';
+import { Direction } from '../inputs/index';
+
+export class Padding {
+ element: HTMLElement;
+ direction: Direction;
+ routines: Routines;
+
+ constructor(direction: Direction, routines: Routines) {
+ const found = routines.findPaddingElement(direction);
+ routines.checkElement(found as HTMLElement);
+ this.element = found as HTMLElement;
+ this.direction = direction;
+ this.routines = routines;
+ }
+
+ reset(size?: number): void {
+ this.size = size || 0;
+ }
+
+ get size(): number {
+ return this.routines.getSizeStyle(this.element);
+ }
+
+ set size(value: number) {
+ this.routines.setSizeStyle(this.element, value);
+ }
+}
+
+export class Paddings {
+ settings: Settings;
+ forward: Padding;
+ backward: Padding;
+
+ constructor(routines: Routines, settings: Settings) {
+ this.settings = settings;
+ this.forward = new Padding(Direction.forward, routines);
+ this.backward = new Padding(Direction.backward, routines);
+ }
+
+ byDirection(direction: Direction, opposite?: boolean): Padding {
+ return direction === Direction.backward
+ ? opposite
+ ? this.forward
+ : this.backward
+ : opposite
+ ? this.backward
+ : this.forward;
+ }
+
+ reset(viewportSize: number, startIndex: number, offset: number): void {
+ const positive = this.getPositiveSize(startIndex, viewportSize, offset);
+ const negative = this.getNegativeSize(startIndex);
+ if (this.settings.inverse) {
+ this.forward.reset(negative);
+ this.backward.reset(positive);
+ const diff = viewportSize - this.backward.size - offset;
+ if (diff > 0) {
+ this.backward.size += diff;
+ this.forward.size -= diff;
+ }
+ } else {
+ this.forward.reset(positive);
+ this.backward.reset(negative);
+ const diff = viewportSize - this.forward.size - offset;
+ if (diff > 0) {
+ this.backward.size -= diff;
+ this.forward.size += diff;
+ }
+ }
+ }
+
+ getPositiveSize(startIndex: number, viewportSize: number, offset: number): number {
+ const { settings } = this;
+ let positiveSize = viewportSize;
+ if (isFinite(settings.maxIndex)) {
+ positiveSize = (settings.maxIndex - startIndex + 1) * settings.itemSize;
+ }
+ if (offset) {
+ positiveSize = Math.max(positiveSize - offset, 0);
+ }
+ return positiveSize;
+ }
+
+ getNegativeSize(startIndex: number): number {
+ const { settings } = this;
+ let negativeSize = 0;
+ if (isFinite(settings.minIndex)) {
+ negativeSize = (startIndex - settings.minIndex) * settings.itemSize;
+ }
+ return negativeSize;
+ }
+}
diff --git a/src/classes/reactive.ts b/src/classes/reactive.ts
index b2056b50..75a0c6ab 100644
--- a/src/classes/reactive.ts
+++ b/src/classes/reactive.ts
@@ -12,7 +12,6 @@ interface Options {
}
export class Reactive {
-
private initialValue: T;
private value: T;
private id: number;
diff --git a/src/classes/settings.ts b/src/classes/settings.ts
index 34fdaced..d758b2f5 100644
--- a/src/classes/settings.ts
+++ b/src/classes/settings.ts
@@ -1,8 +1,20 @@
-import { SETTINGS, DEV_SETTINGS, validate, validateOne, VALIDATORS, SizeStrategy, Direction } from '../inputs/index';
-import { Settings as ISettings, DevSettings as IDevSettings, ICommonProps, ItemsProcessor } from '../interfaces/index';
+import {
+ SETTINGS,
+ DEV_SETTINGS,
+ validate,
+ validateOne,
+ VALIDATORS,
+ SizeStrategy,
+ Direction
+} from '../inputs/index';
+import {
+ Settings as ISettings,
+ DevSettings as IDevSettings,
+ ICommonProps,
+ ItemsProcessor
+} from '../interfaces/index';
export class Settings implements ISettings, IDevSettings {
-
// user settings
adapter: boolean;
startIndex: number;
@@ -25,7 +37,7 @@ export class Settings implements ISettings, IDevSettings {
* Default value: false.
* @type {boolean}
*/
- debug: boolean; // if true,
+ debug: boolean; // if true,
/**
* Development setting.
@@ -51,6 +63,14 @@ export class Settings implements ISettings, IDevSettings {
*/
logProcessRun: boolean;
+ /**
+ * Development setting.
+ * If true, console color formatting will be used in logs.
+ * Default value: true.
+ * @type {boolean}
+ */
+ logColor: boolean;
+
/**
* Development setting.
* If set, scroll event handling is throttled (ms).
@@ -131,7 +151,9 @@ export class Settings implements ISettings, IDevSettings {
viewport: HTMLElement | null;
constructor(
- settings: ISettings | undefined, devSettings: IDevSettings | undefined, instanceIndex: number
+ settings: ISettings | undefined,
+ devSettings: IDevSettings | undefined,
+ instanceIndex: number
) {
this.parseInput(settings, SETTINGS);
this.parseInput(devSettings, DEV_SETTINGS);
@@ -141,7 +163,10 @@ export class Settings implements ISettings, IDevSettings {
// todo: min/max indexes must be ignored if infinite mode is enabled ??
}
- parseInput(input: ISettings | IDevSettings | undefined, props: ICommonProps): void {
+ parseInput(
+ input: ISettings | IDevSettings | undefined,
+ props: ICommonProps
+ ): void {
const result = validate(input, props);
if (!result.isValid) {
throw new Error('Invalid settings');
diff --git a/src/classes/state.ts b/src/classes/state.ts
index 5869b977..a609fc54 100644
--- a/src/classes/state.ts
+++ b/src/classes/state.ts
@@ -1,90 +1,90 @@
-import { Settings } from './settings';
-import { Reactive } from './reactive';
-import { WorkflowCycleModel } from './state/cycle';
-import { FetchModel } from './state/fetch';
-import { ClipModel } from './state/clip';
-import { RenderModel } from './state/render';
-import { ScrollModel } from './state/scroll';
-import { State as IState, IPackages, ProcessName } from '../interfaces/index';
-
-export class State implements IState {
-
- readonly packageInfo: IPackages;
- private settings: Settings;
- initTime: number;
- paused: Reactive;
-
- cycle: WorkflowCycleModel;
- fetch: FetchModel;
- clip: ClipModel;
- render: RenderModel;
- scroll: ScrollModel;
-
- get time(): number {
- return Number(new Date()) - this.initTime;
- }
-
- constructor(packageInfo: IPackages, settings: Settings, state?: IState) {
- this.packageInfo = packageInfo;
- this.settings = settings;
- this.initTime = Number(new Date());
- this.paused = new Reactive(false);
-
- this.cycle = new WorkflowCycleModel(this.settings.instanceIndex, state ? state.cycle : void 0);
- this.fetch = new FetchModel(settings.directionPriority);
- this.clip = new ClipModel();
- this.render = new RenderModel();
- this.scroll = new ScrollModel();
- }
-
- startWorkflowCycle(isInitial: boolean, initiator: ProcessName): void {
- this.cycle.start(isInitial, initiator);
- }
-
- endWorkflowCycle(count: number): void {
- this.cycle.end(count);
- }
-
- startInnerLoop(): { process?: ProcessName, doRender?: boolean } {
- const { cycle, scroll: scroll, fetch, render, clip } = this;
-
- cycle.innerLoop.start();
- scroll.positionBeforeAsync = null;
-
- if (!fetch.simulate) {
- fetch.reset();
- }
- clip.reset(clip.force);
- render.reset();
-
- return {
- ...(cycle.innerLoop.first ? {
- process: cycle.initiator,
- doRender: fetch.simulate && fetch.items.length > 0
- } : {})
- };
- }
-
- endInnerLoop(): void {
- const { fetch, clip, render, cycle } = this;
- fetch.stopSimulate();
- clip.reset(true);
- if (fetch.cancel) {
- fetch.cancel();
- fetch.cancel = null;
- }
- if (render.cancel) {
- render.cancel();
- render.cancel = null;
- }
- cycle.innerLoop.done();
- }
-
- dispose(): void {
- this.scroll.stop();
- this.cycle.dispose();
- this.paused.dispose();
- this.endInnerLoop();
- }
-
-}
+import { Settings } from './settings';
+import { Reactive } from './reactive';
+import { WorkflowCycleModel } from './state/cycle';
+import { FetchModel } from './state/fetch';
+import { ClipModel } from './state/clip';
+import { RenderModel } from './state/render';
+import { ScrollModel } from './state/scroll';
+import { State as IState, IPackages, ProcessName } from '../interfaces/index';
+
+export class State implements IState {
+ readonly packageInfo: IPackages;
+ private settings: Settings;
+ initTime: number;
+ paused: Reactive;
+
+ cycle: WorkflowCycleModel;
+ fetch: FetchModel;
+ clip: ClipModel;
+ render: RenderModel;
+ scroll: ScrollModel;
+
+ get time(): number {
+ return Number(new Date()) - this.initTime;
+ }
+
+ constructor(packageInfo: IPackages, settings: Settings, state?: IState) {
+ this.packageInfo = packageInfo;
+ this.settings = settings;
+ this.initTime = Number(new Date());
+ this.paused = new Reactive(false);
+
+ this.cycle = new WorkflowCycleModel(this.settings.instanceIndex, state ? state.cycle : void 0);
+ this.fetch = new FetchModel(settings.directionPriority);
+ this.clip = new ClipModel();
+ this.render = new RenderModel();
+ this.scroll = new ScrollModel();
+ }
+
+ startWorkflowCycle(isInitial: boolean, initiator: ProcessName): void {
+ this.cycle.start(isInitial, initiator);
+ }
+
+ endWorkflowCycle(count: number): void {
+ this.cycle.end(count);
+ }
+
+ startInnerLoop(): { process?: ProcessName; doRender?: boolean } {
+ const { cycle, scroll: scroll, fetch, render, clip } = this;
+
+ cycle.innerLoop.start();
+ scroll.positionBeforeAsync = null;
+
+ if (!fetch.simulate) {
+ fetch.reset();
+ }
+ clip.reset(clip.force);
+ render.reset();
+
+ return {
+ ...(cycle.innerLoop.first
+ ? {
+ process: cycle.initiator,
+ doRender: fetch.simulate && fetch.items.length > 0
+ }
+ : {})
+ };
+ }
+
+ endInnerLoop(): void {
+ const { fetch, clip, render, cycle } = this;
+ fetch.stopSimulate();
+ clip.reset(true);
+ if (fetch.cancel) {
+ fetch.cancel();
+ fetch.cancel = null;
+ }
+ if (render.cancel) {
+ render.cancel();
+ render.cancel = null;
+ }
+ cycle.innerLoop.done();
+ }
+
+ dispose(): void {
+ this.scroll.stop();
+ this.cycle.dispose();
+ this.paused.dispose();
+ this.endInnerLoop();
+ }
+}
diff --git a/src/classes/state/clip.ts b/src/classes/state/clip.ts
index f2fa558c..90b145a4 100644
--- a/src/classes/state/clip.ts
+++ b/src/classes/state/clip.ts
@@ -20,5 +20,4 @@ export class ClipModel {
this.forceBackward = false;
}
}
-
}
diff --git a/src/classes/state/fetch.ts b/src/classes/state/fetch.ts
index bbbe04a7..fe52d4b2 100644
--- a/src/classes/state/fetch.ts
+++ b/src/classes/state/fetch.ts
@@ -122,7 +122,7 @@ export class FetchModel {
}
get hasNewItems(): boolean {
- return !!((this._newItemsData && this._newItemsData.length));
+ return !!(this._newItemsData && this._newItemsData.length);
}
get index(): number {
@@ -130,7 +130,9 @@ export class FetchModel {
}
get count(): number {
- return !isNaN(this.first.index) && !isNaN(this.last.index) ? this.last.index - this.first.index + 1 : 0;
+ return !isNaN(this.first.index) && !isNaN(this.last.index)
+ ? this.last.index - this.first.index + 1
+ : 0;
}
shouldCheckPreSizeExpectation(lastBufferedIndex: number): boolean {
diff --git a/src/classes/viewport.ts b/src/classes/viewport.ts
index b9d75ad7..f2733d06 100644
--- a/src/classes/viewport.ts
+++ b/src/classes/viewport.ts
@@ -7,7 +7,6 @@ import { Logger } from './logger';
import { Direction } from '../inputs/index';
export class Viewport {
-
offset: number;
paddings: Paddings;
@@ -40,7 +39,9 @@ export class Viewport {
this.routines.setScrollPosition(value);
const position = this.scrollPosition;
this.logger.log(() => [
- 'setting scroll position at', position, ...(position !== value ? [`(${value})`] : [])
+ 'setting scroll position at',
+ position,
+ ...(position !== value ? [`(${value})`] : [])
]);
return position;
}
@@ -81,11 +82,15 @@ export class Viewport {
return this.routines.findItemElement(id);
}
- getEdgeVisibleItem(items: Item[], direction: Direction): { item?: Item, index: number, diff: number } {
+ getEdgeVisibleItem(
+ items: Item[],
+ direction: Direction
+ ): { item?: Item; index: number; diff: number } {
const bwd = direction === Direction.backward;
const opposite = bwd ? Direction.forward : Direction.backward;
const viewportEdge = this.getEdge(direction);
- let item, diff = 0;
+ let item,
+ diff = 0;
for (
let i = bwd ? 0 : items.length - 1;
bwd ? i <= items.length - 1 : i >= 0;
@@ -93,12 +98,11 @@ export class Viewport {
) {
const itemEdge = this.routines.getEdge(items[i].element, opposite);
diff = itemEdge - viewportEdge;
- if (bwd && diff > 0 || !bwd && diff < 0) {
+ if ((bwd && diff > 0) || (!bwd && diff < 0)) {
item = items[i];
break;
}
}
return { item, index: item ? item.$index : NaN, diff };
}
-
}
diff --git a/src/index.ts b/src/index.ts
index 6506f441..01c4158a 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -14,7 +14,7 @@ import {
IAdapterConfig,
ItemAdapter,
IAdapter,
- Item,
+ Item
} from './interfaces/index';
// export entities
@@ -28,7 +28,7 @@ export {
EMPTY_ITEM,
getDefaultAdapterProps,
Direction,
- SizeStrategy,
+ SizeStrategy
};
// export interfaces
@@ -40,5 +40,5 @@ export {
IAdapterConfig,
ItemAdapter as IAdapterItem,
IAdapter,
- Item,
+ Item
};
diff --git a/src/inputs/adapter.ts b/src/inputs/adapter.ts
index 30df33fc..eecd6447 100644
--- a/src/inputs/adapter.ts
+++ b/src/inputs/adapter.ts
@@ -14,10 +14,10 @@ const {
FUNC_WITH_X_TO_Y_ARGUMENTS,
ONE_OF_MUST,
ONE_OF_CAN,
- OR,
+ OR
} = VALIDATORS;
-enum AdapterNoParams { }
+enum AdapterNoParams {}
const NO_METHOD_PARAMS: ICommonProps = {};
const RESET_METHOD_PARAMS: ICommonProps = {
@@ -29,24 +29,24 @@ const RESET_METHOD_PARAMS: ICommonProps = {
},
[AdapterResetParams.devSettings]: {
validators: [OBJECT]
- },
+ }
};
enum AdapterReloadParams {
- reloadIndex = 'reloadIndex',
+ reloadIndex = 'reloadIndex'
}
const RELOAD_METHOD_PARAMS: ICommonProps = {
[AdapterReloadParams.reloadIndex]: {
validators: [INTEGER]
- },
+ }
};
enum AdapterPrependParams {
items = 'items',
bof = 'bof',
increase = 'increase',
- virtualize = 'virtualize',
+ virtualize = 'virtualize'
}
const PREPEND_METHOD_PARAMS: ICommonProps = {
@@ -65,14 +65,14 @@ const PREPEND_METHOD_PARAMS: ICommonProps = {
[AdapterPrependParams.virtualize]: {
validators: [BOOLEAN, ONE_OF_CAN([AdapterPrependParams.bof])],
defaultValue: false
- },
+ }
};
enum AdapterAppendParams {
items = 'items',
eof = 'eof',
decrease = 'decrease',
- virtualize = 'virtualize',
+ virtualize = 'virtualize'
}
const APPEND_METHOD_PARAMS: ICommonProps = {
@@ -91,13 +91,13 @@ const APPEND_METHOD_PARAMS: ICommonProps = {
[AdapterPrependParams.virtualize]: {
validators: [BOOLEAN, ONE_OF_CAN([AdapterAppendParams.eof])],
defaultValue: false
- },
+ }
};
enum AdapterRemoveParams {
predicate = 'predicate',
indexes = 'indexes',
- increase = 'increase',
+ increase = 'increase'
}
const REMOVE_METHOD_PARAMS: ICommonProps = {
@@ -110,12 +110,12 @@ const REMOVE_METHOD_PARAMS: ICommonProps = {
[AdapterRemoveParams.increase]: {
validators: [BOOLEAN],
defaultValue: false
- },
+ }
};
enum AdapterClipParams {
backwardOnly = 'backwardOnly',
- forwardOnly = 'forwardOnly',
+ forwardOnly = 'forwardOnly'
}
const CLIP_METHOD_PARAMS: ICommonProps = {
@@ -126,7 +126,7 @@ const CLIP_METHOD_PARAMS: ICommonProps = {
[AdapterClipParams.forwardOnly]: {
validators: [BOOLEAN, ONE_OF_CAN([AdapterClipParams.backwardOnly])],
defaultValue: false
- },
+ }
};
enum AdapterInsertParams {
@@ -135,7 +135,7 @@ enum AdapterInsertParams {
after = 'after',
beforeIndex = 'beforeIndex',
afterIndex = 'afterIndex',
- decrease = 'decrease',
+ decrease = 'decrease'
}
const INSERT_METHOD_PARAMS: ICommonProps = {
@@ -144,35 +144,55 @@ const INSERT_METHOD_PARAMS: ICommonProps = {
mandatory: true
},
[AdapterInsertParams.before]: {
- validators: [FUNC_WITH_X_ARGUMENTS(1), ONE_OF_MUST([
- AdapterInsertParams.after, AdapterInsertParams.beforeIndex, AdapterInsertParams.afterIndex
- ])]
+ validators: [
+ FUNC_WITH_X_ARGUMENTS(1),
+ ONE_OF_MUST([
+ AdapterInsertParams.after,
+ AdapterInsertParams.beforeIndex,
+ AdapterInsertParams.afterIndex
+ ])
+ ]
},
[AdapterInsertParams.after]: {
- validators: [FUNC_WITH_X_ARGUMENTS(1), ONE_OF_MUST([
- AdapterInsertParams.before, AdapterInsertParams.beforeIndex, AdapterInsertParams.afterIndex
- ])]
+ validators: [
+ FUNC_WITH_X_ARGUMENTS(1),
+ ONE_OF_MUST([
+ AdapterInsertParams.before,
+ AdapterInsertParams.beforeIndex,
+ AdapterInsertParams.afterIndex
+ ])
+ ]
},
[AdapterInsertParams.beforeIndex]: {
- validators: [INTEGER, ONE_OF_MUST([
- AdapterInsertParams.before, AdapterInsertParams.after, AdapterInsertParams.afterIndex
- ])]
+ validators: [
+ INTEGER,
+ ONE_OF_MUST([
+ AdapterInsertParams.before,
+ AdapterInsertParams.after,
+ AdapterInsertParams.afterIndex
+ ])
+ ]
},
[AdapterInsertParams.afterIndex]: {
- validators: [INTEGER, ONE_OF_MUST([
- AdapterInsertParams.before, AdapterInsertParams.after, AdapterInsertParams.beforeIndex
- ])]
+ validators: [
+ INTEGER,
+ ONE_OF_MUST([
+ AdapterInsertParams.before,
+ AdapterInsertParams.after,
+ AdapterInsertParams.beforeIndex
+ ])
+ ]
},
[AdapterInsertParams.decrease]: {
validators: [BOOLEAN],
defaultValue: false
- },
+ }
};
enum AdapterReplaceParams {
items = 'items',
predicate = 'predicate',
- fixRight = 'fixRight',
+ fixRight = 'fixRight'
}
const REPLACE_METHOD_PARAMS: ICommonProps = {
@@ -192,7 +212,7 @@ const REPLACE_METHOD_PARAMS: ICommonProps = {
enum AdapterUpdateParams {
predicate = 'predicate',
- fixRight = 'fixRight',
+ fixRight = 'fixRight'
}
const UPDATE_METHOD_PARAMS: ICommonProps = {
@@ -203,7 +223,7 @@ const UPDATE_METHOD_PARAMS: ICommonProps = {
[AdapterUpdateParams.fixRight]: {
validators: [BOOLEAN],
defaultValue: false
- },
+ }
};
enum AdapterFixParams {
@@ -212,7 +232,7 @@ enum AdapterFixParams {
maxIndex = 'maxIndex',
updater = 'updater',
scrollToItem = 'scrollToItem',
- scrollToItemOpt = 'scrollToItemOpt',
+ scrollToItemOpt = 'scrollToItemOpt'
}
const FIX_METHOD_PARAMS: ICommonProps = {
@@ -233,7 +253,7 @@ const FIX_METHOD_PARAMS: ICommonProps = {
},
[AdapterFixParams.scrollToItemOpt]: {
validators: [OR([BOOLEAN, OBJECT])]
- },
+ }
};
export const AdapterMethods: AdapterProcessMap<{ [key: string]: string }> = {
@@ -248,7 +268,7 @@ export const AdapterMethods: AdapterProcessMap<{ [key: string]: string }> = {
[Process.replace]: AdapterReplaceParams,
[Process.update]: AdapterUpdateParams,
[Process.pause]: AdapterNoParams,
- [Process.fix]: AdapterFixParams,
+ [Process.fix]: AdapterFixParams
};
export const ADAPTER_METHODS: AdapterProcessMap> = {
@@ -263,5 +283,5 @@ export const ADAPTER_METHODS: AdapterProcessMap> = {
[Process.replace]: REPLACE_METHOD_PARAMS,
[Process.update]: UPDATE_METHOD_PARAMS,
[Process.pause]: NO_METHOD_PARAMS,
- [Process.fix]: FIX_METHOD_PARAMS,
+ [Process.fix]: FIX_METHOD_PARAMS
};
diff --git a/src/inputs/datasource.ts b/src/inputs/datasource.ts
index bf166cbe..8b406915 100644
--- a/src/inputs/datasource.ts
+++ b/src/inputs/datasource.ts
@@ -6,7 +6,7 @@ const { OBJECT, FUNC_WITH_X_AND_MORE_ARGUMENTS } = VALIDATORS;
export enum DatasourceProps {
get = 'get',
settings = 'settings',
- devSettings = 'devSettings',
+ devSettings = 'devSettings'
}
export const DATASOURCE: ICommonProps = {
diff --git a/src/inputs/index.ts b/src/inputs/index.ts
index 8ecf4445..c8321afa 100644
--- a/src/inputs/index.ts
+++ b/src/inputs/index.ts
@@ -18,5 +18,5 @@ export {
DEV_SETTINGS,
AdapterMethods,
ADAPTER_METHODS,
- WORKFLOW,
+ WORKFLOW
};
diff --git a/src/inputs/settings.ts b/src/inputs/settings.ts
index 8e821253..9cebcb4c 100644
--- a/src/inputs/settings.ts
+++ b/src/inputs/settings.ts
@@ -2,7 +2,8 @@ import { VALIDATORS } from './validation';
import { ICommonProps } from '../interfaces/index';
import { SizeStrategy, Direction } from './common';
-const { NUMBER, INTEGER, INTEGER_UNLIMITED, MORE_OR_EQUAL, BOOLEAN, ELEMENT, FUNC, OR, ENUM } = VALIDATORS;
+const { NUMBER, INTEGER, INTEGER_UNLIMITED, MORE_OR_EQUAL, BOOLEAN, ELEMENT, FUNC, OR, ENUM } =
+ VALIDATORS;
enum Settings {
adapter = 'adapter',
@@ -18,7 +19,7 @@ enum Settings {
viewportElement = 'viewportElement',
inverse = 'inverse',
onBeforeClip = 'onBeforeClip',
- sizeStrategy = 'sizeStrategy',
+ sizeStrategy = 'sizeStrategy'
}
enum DevSettings {
@@ -26,13 +27,14 @@ enum DevSettings {
immediateLog = 'immediateLog',
logProcessRun = 'logProcessRun',
logTime = 'logTime',
+ logColor = 'logColor',
throttle = 'throttle',
initDelay = 'initDelay',
initWindowDelay = 'initWindowDelay',
cacheData = 'cacheData',
cacheOnReload = 'cacheOnReload',
dismissOverflowAnchor = 'dismissOverflowAnchor',
- directionPriority = 'directionPriority',
+ directionPriority = 'directionPriority'
}
export const MIN = {
@@ -41,7 +43,7 @@ export const MIN = {
[Settings.padding]: 0.01,
[DevSettings.throttle]: 0,
[DevSettings.initDelay]: 0,
- [DevSettings.initWindowDelay]: 0,
+ [DevSettings.initWindowDelay]: 0
};
export const SETTINGS: ICommonProps = {
@@ -100,7 +102,7 @@ export const SETTINGS: ICommonProps = {
[Settings.sizeStrategy]: {
validators: [ENUM(SizeStrategy)],
defaultValue: SizeStrategy.Average
- },
+ }
};
export const DEV_SETTINGS: ICommonProps = {
@@ -120,6 +122,10 @@ export const DEV_SETTINGS: ICommonProps = {
validators: [BOOLEAN],
defaultValue: false
},
+ [DevSettings.logColor]: {
+ validators: [BOOLEAN],
+ defaultValue: true
+ },
[DevSettings.throttle]: {
validators: [INTEGER, MORE_OR_EQUAL(MIN[DevSettings.throttle], true)],
defaultValue: 40
@@ -147,5 +153,5 @@ export const DEV_SETTINGS: ICommonProps = {
[DevSettings.directionPriority]: {
validators: [ENUM(Direction)],
defaultValue: Direction.backward
- },
+ }
};
diff --git a/src/inputs/validation.ts b/src/inputs/validation.ts
index 58399edc..16d45a25 100644
--- a/src/inputs/validation.ts
+++ b/src/inputs/validation.ts
@@ -5,7 +5,7 @@ import {
IValidatedData,
IValidatedCommonProps,
ICommonProps,
- ICommonProp,
+ ICommonProp
} from '../interfaces/index';
export enum ValidatorType {
@@ -24,16 +24,14 @@ export enum ValidatorType {
oneOfCan = 'can be present as only one item of {arg1} list',
oneOfMust = 'must be present as only one item of {arg1} list',
or = 'must satisfy at least 1 validator from {arg1} list',
- enum = 'must belong to {arg1} list',
+ enum = 'must belong to {arg1} list'
}
const getError = (msg: ValidatorType, args?: string[]) =>
(args || ['']).reduce((acc, arg, index) => acc.replace(`{arg${index + 1}}`, arg), msg);
const getNumber = (value: unknown): number =>
- typeof value === 'number' || (typeof value === 'string' && value !== '')
- ? Number(value)
- : NaN;
+ typeof value === 'number' || (typeof value === 'string' && value !== '') ? Number(value) : NaN;
const onNumber = (value: unknown): ValidatedValue => {
const parsedValue = getNumber(value);
@@ -69,22 +67,24 @@ const onIntegerUnlimited = (value: unknown): ValidatedValue => {
return { value: parsedValue, isSet: true, isValid: !errors.length, errors };
};
-const onMoreOrEqual = (limit: number, fallback?: boolean) => (value: unknown): ValidatedValue => {
- const result = onNumber(value);
- if (!result.isValid) {
- return result;
- }
- let parsedValue = result.value as number;
- const errors = [];
- if (parsedValue < limit) {
- if (!fallback) {
- errors.push(getError(ValidatorType.moreOrEqual, [String(limit)]));
- } else {
- parsedValue = limit;
+const onMoreOrEqual =
+ (limit: number, fallback?: boolean) =>
+ (value: unknown): ValidatedValue => {
+ const result = onNumber(value);
+ if (!result.isValid) {
+ return result;
}
- }
- return { value: parsedValue, isSet: true, isValid: !errors.length, errors };
-};
+ let parsedValue = result.value as number;
+ const errors = [];
+ if (parsedValue < limit) {
+ if (!fallback) {
+ errors.push(getError(ValidatorType.moreOrEqual, [String(limit)]));
+ } else {
+ parsedValue = limit;
+ }
+ }
+ return { value: parsedValue, isSet: true, isValid: !errors.length, errors };
+ };
const onBoolean = (value: unknown): ValidatedValue => {
const errors = [];
@@ -159,81 +159,93 @@ const onFunctionWithXArguments = (argsCount: number) => (value: unknown) => {
return { value: value as Func, isSet: true, isValid: !errors.length, errors };
};
-const onFunctionWithXAndMoreArguments = (argsCount: number) => (value: unknown): ValidatedValue => {
- const result = onFunction(value);
- if (!result.isValid) {
- return result;
- }
- value = result.value;
- const errors = [];
- if ((value as Func).length < argsCount) {
- errors.push(getError(ValidatorType.funcOfxArguments, [String(argsCount)]));
- }
- return { value: value as Func, isSet: true, isValid: !errors.length, errors };
-};
+const onFunctionWithXAndMoreArguments =
+ (argsCount: number) =>
+ (value: unknown): ValidatedValue => {
+ const result = onFunction(value);
+ if (!result.isValid) {
+ return result;
+ }
+ value = result.value;
+ const errors = [];
+ if ((value as Func).length < argsCount) {
+ errors.push(getError(ValidatorType.funcOfxArguments, [String(argsCount)]));
+ }
+ return { value: value as Func, isSet: true, isValid: !errors.length, errors };
+ };
-const onFunctionWithXToYArguments = (from: number, to: number) => (value: unknown): ValidatedValue => {
- const result = onFunction(value);
- if (!result.isValid) {
- return result;
- }
- value = result.value;
- const errors = [];
- if ((value as Func).length < from || (value as Func).length > to) {
- errors.push(getError(ValidatorType.funcOfXToYArguments, [String(from), String(to)]));
- }
- return { value: value as Func, isSet: true, isValid: !errors.length, errors };
-};
+const onFunctionWithXToYArguments =
+ (from: number, to: number) =>
+ (value: unknown): ValidatedValue => {
+ const result = onFunction(value);
+ if (!result.isValid) {
+ return result;
+ }
+ value = result.value;
+ const errors = [];
+ if ((value as Func).length < from || (value as Func).length > to) {
+ errors.push(getError(ValidatorType.funcOfXToYArguments, [String(from), String(to)]));
+ }
+ return { value: value as Func, isSet: true, isValid: !errors.length, errors };
+ };
-const onOneOf = (tokens: string[], must: boolean) => (value: unknown, context?: IValidationContext): ValidatedValue => {
- const errors = [];
- const isSet = value !== void 0;
- let noOneIsPresent = !isSet;
- const err = must ? ValidatorType.oneOfMust : ValidatorType.oneOfCan;
- if (!Array.isArray(tokens) || !tokens.length) {
- errors.push(getError(err, ['undefined']));
- } else {
- for (let i = tokens.length - 1; i >= 0; i--) {
- const token = tokens[i];
- if (typeof token !== 'string') {
- errors.push(getError(err, [tokens.join('", "')]) + ' (non-string token)');
- break;
- }
- const isAnotherPresent = context && Object.prototype.hasOwnProperty.call(context, token);
- if (isSet && isAnotherPresent) {
- errors.push(getError(err, [tokens.join('", "')]) + ` (${token} is present)`);
- break;
+const onOneOf =
+ (tokens: string[], must: boolean) =>
+ (value: unknown, context?: IValidationContext): ValidatedValue => {
+ const errors = [];
+ const isSet = value !== void 0;
+ let noOneIsPresent = !isSet;
+ const err = must ? ValidatorType.oneOfMust : ValidatorType.oneOfCan;
+ if (!Array.isArray(tokens) || !tokens.length) {
+ errors.push(getError(err, ['undefined']));
+ } else {
+ for (let i = tokens.length - 1; i >= 0; i--) {
+ const token = tokens[i];
+ if (typeof token !== 'string') {
+ errors.push(getError(err, [tokens.join('", "')]) + ' (non-string token)');
+ break;
+ }
+ const isAnotherPresent = context && Object.prototype.hasOwnProperty.call(context, token);
+ if (isSet && isAnotherPresent) {
+ errors.push(getError(err, [tokens.join('", "')]) + ` (${token} is present)`);
+ break;
+ }
+ if (noOneIsPresent && isAnotherPresent) {
+ noOneIsPresent = false;
+ }
}
- if (noOneIsPresent && isAnotherPresent) {
- noOneIsPresent = false;
+ if (must && noOneIsPresent) {
+ errors.push(getError(err, [tokens.join('", "')]));
}
}
- if (must && noOneIsPresent) {
- errors.push(getError(err, [tokens.join('", "')]));
- }
- }
- return { value, isSet, isValid: !errors.length, errors };
-};
+ return { value, isSet, isValid: !errors.length, errors };
+ };
-const onOr = (validators: IValidator[]) => (value: unknown): ValidatedValue => {
- const errors = [];
- if (validators.every(validator => !validator.method(value).isValid)) {
- errors.push(validators.map(v => v.type).join(' OR '));
- }
- return { value, isSet: true, isValid: !errors.length, errors };
-};
+const onOr =
+ (validators: IValidator[]) =>
+ (value: unknown): ValidatedValue => {
+ const errors = [];
+ if (validators.every(validator => !validator.method(value).isValid)) {
+ errors.push(validators.map(v => v.type).join(' OR '));
+ }
+ return { value, isSet: true, isValid: !errors.length, errors };
+ };
type AbstractEnum = Record;
type TEnum = AbstractEnum;
-const onEnum = (list: TEnum) => (value: unknown): ValidatedValue => {
- const errors = [];
- const values = Object.keys(list).filter(k => isNaN(Number(k))).map(k => list[k as unknown as number]);
- if (!values.some(item => item === value)) {
- errors.push(getError(ValidatorType.enum, ['[' + values.join(',') + ']']));
- }
- return { value, isSet: true, isValid: !errors.length, errors };
-};
+const onEnum =
+ (list: TEnum) =>
+ (value: unknown): ValidatedValue => {
+ const errors = [];
+ const values = Object.keys(list)
+ .filter(k => isNaN(Number(k)))
+ .map(k => list[k as unknown as number]);
+ if (!values.some(item => item === value)) {
+ errors.push(getError(ValidatorType.enum, ['[' + values.join(',') + ']']));
+ }
+ return { value, isSet: true, isValid: !errors.length, errors };
+ };
export const VALIDATORS = {
NUMBER: {
@@ -303,7 +315,6 @@ export const VALIDATORS = {
};
export class ValidatedData implements IValidatedData {
-
context: IValidationContext;
isValidContext: boolean;
isValid: boolean;
@@ -331,9 +342,10 @@ export class ValidatedData implements IValidatedData {
}
private setValidity() {
- this.errors = Object.keys(this.params).reduce((acc: string[], key: string) => [
- ...acc, ...this.params[key].errors
- ], []);
+ this.errors = Object.keys(this.params).reduce(
+ (acc: string[], key: string) => [...acc, ...this.params[key].errors],
+ []
+ );
this.isValid = !this.errors.length;
}
@@ -347,18 +359,14 @@ export class ValidatedData implements IValidatedData {
if (!value.isValid) {
value.errors = !value.isSet
? [`"${token}" must be set`]
- : value.errors.map((err: string) =>
- `"${token}" ${err}`
- );
+ : value.errors.map((err: string) => `"${token}" ${err}`);
}
this.params[token] = value;
this.setValidity();
}
showErrors(): string {
- return this.errors.length
- ? 'validation failed: ' + this.errors.join(', ')
- : '';
+ return this.errors.length ? 'validation failed: ' + this.errors.join(', ') : '';
}
}
@@ -382,7 +390,7 @@ const getDefault = (value: unknown, prop: ICommonProp): ValidatedValue => {
const empty = value === void 0;
const auto = !prop.mandatory && prop.defaultValue !== void 0;
return {
- value: !empty ? value : (auto ? prop.defaultValue : void 0),
+ value: !empty ? value : auto ? prop.defaultValue : void 0,
isSet: !empty || auto,
isValid: !empty || !prop.mandatory,
errors: []
@@ -390,7 +398,9 @@ const getDefault = (value: unknown, prop: ICommonProp): ValidatedValue => {
};
export const validateOne = (
- context: IValidationContext, name: string, prop: ICommonProp
+ context: IValidationContext,
+ name: string,
+ prop: ICommonProp
): ValidatedValue => {
const result = getDefault(context[name], prop);
if (!result.isSet) {
@@ -415,14 +425,12 @@ export const validateOne = (
return result;
};
-export const validate = (
- context: unknown, params: ICommonProps
-): IValidatedData => {
+export const validate = (context: unknown, params: ICommonProps): IValidatedData => {
const data = new ValidatedData(context);
Object.entries(params).forEach(([key, prop]) =>
- data.setParam(key, data.isValidContext
- ? validateOne(data.context, key, prop)
- : getDefault(void 0, prop)
+ data.setParam(
+ key,
+ data.isValidContext ? validateOne(data.context, key, prop) : getDefault(void 0, prop)
)
);
return data;
diff --git a/src/inputs/workflow.ts b/src/inputs/workflow.ts
index f1aacd65..1f2adb10 100644
--- a/src/inputs/workflow.ts
+++ b/src/inputs/workflow.ts
@@ -8,7 +8,7 @@ export enum WorkflowProps {
element = 'element',
datasource = 'datasource',
run = 'run',
- Routines = 'Routines',
+ Routines = 'Routines'
}
export const WORKFLOW: ICommonProps = {
diff --git a/src/interfaces/datasource.ts b/src/interfaces/datasource.ts
index b3ffa30c..1e86b8be 100644
--- a/src/interfaces/datasource.ts
+++ b/src/interfaces/datasource.ts
@@ -8,7 +8,12 @@ export interface ObservableLike {
subscribe(next: SuccessFn, error: ErrorFn, complete: () => void): { unsubscribe: () => void };
}
-type DSGetCallback = (index: number, count: number, success: SuccessFn, fail?: ErrorFn) => void;
+type DSGetCallback = (
+ index: number,
+ count: number,
+ success: SuccessFn,
+ fail?: ErrorFn
+) => void;
type DSGetObservable = (index: number, count: number) => ObservableLike;
type DSGetPromise = (index: number, count: number) => PromiseLike;
diff --git a/src/interfaces/index.ts b/src/interfaces/index.ts
index d50f2320..13653b24 100644
--- a/src/interfaces/index.ts
+++ b/src/interfaces/index.ts
@@ -4,7 +4,7 @@ import {
IDatasourceParams,
IDatasourceOptional,
IDatasource,
- IDatasourceConstructed,
+ IDatasourceConstructed
} from './datasource';
import {
OnDataChanged,
@@ -15,7 +15,7 @@ import {
WorkflowError,
InterruptParams,
StateMachineMethods,
- StateMachineParams,
+ StateMachineParams
} from './workflow';
import { Item } from './item';
import {
@@ -43,7 +43,7 @@ import {
AdapterUpdateOptions,
AdapterFixOptions,
AdapterMethodResult,
- IAdapter,
+ IAdapter
} from './adapter';
import { Settings, DevSettings } from './settings';
import { IRoutines, RoutinesClassType } from './routines';
@@ -55,7 +55,7 @@ import {
ProcessSubject,
AdapterProcessMap,
IBaseProcess,
- IBaseAdapterProcess,
+ IBaseAdapterProcess
} from './process';
import {
ValidatedValue,
@@ -63,7 +63,7 @@ import {
ICommonProp,
ICommonProps,
IValidatedCommonProps,
- IValidatedData,
+ IValidatedData
} from './validation';
export {
@@ -126,5 +126,5 @@ export {
ICommonProp,
ICommonProps,
IValidatedCommonProps,
- IValidatedData,
+ IValidatedData
};
diff --git a/src/interfaces/process.ts b/src/interfaces/process.ts
index d793b5c2..b66ddc22 100644
--- a/src/interfaces/process.ts
+++ b/src/interfaces/process.ts
@@ -1,45 +1,48 @@
-import { Scroller } from '../scroller';
-import { CommonProcess, AdapterProcess, ProcessStatus } from '../processes/index';
-import { IDatasourceConstructed } from './datasource';
-import { IAdapterInput } from './adapter';
-
-export type ProcessName = CommonProcess | AdapterProcess;
-
-export interface ProcessClass {
- process: ProcessName;
-
- run: (scroller: Scroller, ...args: any[]) => void;
- name: string;
-}
-
-export interface ProcessPayload {
- process?: ProcessName;
- options?: unknown;
- event?: Event;
- finalize?: boolean;
- doClip?: boolean;
- doRender?: boolean;
- datasource?: IDatasourceConstructed;
- error?: unknown;
-}
-
-export interface ProcessSubject {
- process: ProcessName;
- status: ProcessStatus;
- payload?: ProcessPayload;
-}
-
-export type AdapterProcessMap = {
- [key in AdapterProcess]: T;
-};
-
-export interface IBaseProcess {
- new(): any; // eslint-disable-line @typescript-eslint/no-explicit-any
- process: ProcessName;
-}
-
-export interface IBaseAdapterProcess extends IBaseProcess {
- parseInput: (
- scroller: Scroller, options: T, ignoreErrors?: boolean, process?: AdapterProcess
- ) => IAdapterInput;
-}
+import { Scroller } from '../scroller';
+import { CommonProcess, AdapterProcess, ProcessStatus } from '../processes/index';
+import { IDatasourceConstructed } from './datasource';
+import { IAdapterInput } from './adapter';
+
+export type ProcessName = CommonProcess | AdapterProcess;
+
+export interface ProcessClass {
+ process: ProcessName;
+
+ run: (scroller: Scroller, ...args: any[]) => void;
+ name: string;
+}
+
+export interface ProcessPayload {
+ process?: ProcessName;
+ options?: unknown;
+ event?: Event;
+ finalize?: boolean;
+ doClip?: boolean;
+ doRender?: boolean;
+ datasource?: IDatasourceConstructed;
+ error?: unknown;
+}
+
+export interface ProcessSubject {
+ process: ProcessName;
+ status: ProcessStatus;
+ payload?: ProcessPayload;
+}
+
+export type AdapterProcessMap = {
+ [key in AdapterProcess]: T;
+};
+
+export interface IBaseProcess {
+ new (): any; // eslint-disable-line @typescript-eslint/no-explicit-any
+ process: ProcessName;
+}
+
+export interface IBaseAdapterProcess extends IBaseProcess {
+ parseInput: (
+ scroller: Scroller,
+ options: T,
+ ignoreErrors?: boolean,
+ process?: AdapterProcess
+ ) => IAdapterInput;
+}
diff --git a/src/interfaces/routines.ts b/src/interfaces/routines.ts
index b11321c8..c5fb665b 100644
--- a/src/interfaces/routines.ts
+++ b/src/interfaces/routines.ts
@@ -14,15 +14,14 @@ interface IRoutinesSettings {
*/
horizontal: boolean;
- /** Determines wether the entire window is the scroller's viewport or not.
+ /** Determines wether the entire window is the scroller's viewport or not.
* The value is equal to settings.window.
*/
window: boolean;
}
export interface IRoutines {
-
- /** Internal prop that is available after instantiation.
+ /** Internal prop that is available after instantiation.
* Reduced version of the App settings object.
*/
readonly settings: IRoutinesSettings;
@@ -47,7 +46,7 @@ export interface IRoutines {
* "settings.viewport", "settings.window" and "element".
* This method is being called during Routines instantiation
* to determine the "viewport" prop:
- *
+ *
* this.viewport = this.getViewportElement();
* @returns {HTMLElement} HTML element.
*/
@@ -191,7 +190,6 @@ export interface IRoutines {
* @returns {function} Callback to dismiss scroll event listener.
*/
onScroll: (handler: EventListener) => () => void;
-
}
export type RoutinesClassType = new (...args: ConstructorParameters) => Routines;
diff --git a/src/interfaces/settings.ts b/src/interfaces/settings.ts
index d83b866a..12a27694 100644
--- a/src/interfaces/settings.ts
+++ b/src/interfaces/settings.ts
@@ -1,33 +1,34 @@
-import { ItemsProcessor } from './adapter';
-import { SizeStrategy } from '../inputs/index';
-
-export interface Settings {
- adapter?: boolean;
- startIndex?: number;
- minIndex?: number;
- maxIndex?: number;
- itemSize?: number;
- bufferSize?: number;
- padding?: number;
- infinite?: boolean;
- horizontal?: boolean;
- windowViewport?: boolean;
- viewportElement?: HTMLElement | (() => void) | null;
- inverse?: boolean;
- onBeforeClip?: ItemsProcessor | null;
- sizeStrategy?: SizeStrategy;
-}
-
-export interface DevSettings {
- debug?: boolean;
- immediateLog?: boolean;
- logProcessRun?: boolean;
- logTime?: boolean;
- throttle?: number;
- initDelay?: number;
- initWindowDelay?: number;
- cacheData?: boolean;
- cacheOnReload?: boolean;
- dismissOverflowAnchor?: boolean;
- directionPriority?: 'backward' | 'forward';
-}
+import { ItemsProcessor } from './adapter';
+import { SizeStrategy } from '../inputs/index';
+
+export interface Settings {
+ adapter?: boolean;
+ startIndex?: number;
+ minIndex?: number;
+ maxIndex?: number;
+ itemSize?: number;
+ bufferSize?: number;
+ padding?: number;
+ infinite?: boolean;
+ horizontal?: boolean;
+ windowViewport?: boolean;
+ viewportElement?: HTMLElement | (() => void) | null;
+ inverse?: boolean;
+ onBeforeClip?: ItemsProcessor | null;
+ sizeStrategy?: SizeStrategy;
+}
+
+export interface DevSettings {
+ debug?: boolean;
+ immediateLog?: boolean;
+ logProcessRun?: boolean;
+ logTime?: boolean;
+ logColor?: boolean;
+ throttle?: number;
+ initDelay?: number;
+ initWindowDelay?: number;
+ cacheData?: boolean;
+ cacheOnReload?: boolean;
+ dismissOverflowAnchor?: boolean;
+ directionPriority?: 'backward' | 'forward';
+}
diff --git a/src/interfaces/state.ts b/src/interfaces/state.ts
index 1962423a..7e9c4440 100644
--- a/src/interfaces/state.ts
+++ b/src/interfaces/state.ts
@@ -1,26 +1,26 @@
-import { Direction } from '../inputs/index';
-import { Reactive } from '../classes/reactive';
-import { WorkflowCycleModel } from '../classes/state/cycle';
-import { FetchModel } from '../classes/state/fetch';
-import { ClipModel } from '../classes/state/clip';
-import { RenderModel } from '../classes/state/render';
-import { ScrollModel } from '../classes/state/scroll';
-import { IPackages } from './adapter';
-
-export interface ScrollEventData {
- time: number;
- position: number;
- direction: Direction | null;
-}
-
-export interface State {
- packageInfo: IPackages;
- initTime: number;
- paused: Reactive;
- cycle: WorkflowCycleModel;
- fetch: FetchModel;
- clip: ClipModel;
- render: RenderModel;
- scroll: ScrollModel;
- time: number;
-}
+import { Direction } from '../inputs/index';
+import { Reactive } from '../classes/reactive';
+import { WorkflowCycleModel } from '../classes/state/cycle';
+import { FetchModel } from '../classes/state/fetch';
+import { ClipModel } from '../classes/state/clip';
+import { RenderModel } from '../classes/state/render';
+import { ScrollModel } from '../classes/state/scroll';
+import { IPackages } from './adapter';
+
+export interface ScrollEventData {
+ time: number;
+ position: number;
+ direction: Direction | null;
+}
+
+export interface State {
+ packageInfo: IPackages;
+ initTime: number;
+ paused: Reactive;
+ cycle: WorkflowCycleModel;
+ fetch: FetchModel;
+ clip: ClipModel;
+ render: RenderModel;
+ scroll: ScrollModel;
+ time: number;
+}
diff --git a/src/interfaces/validation.ts b/src/interfaces/validation.ts
index 6e96e875..dfb692e7 100644
--- a/src/interfaces/validation.ts
+++ b/src/interfaces/validation.ts
@@ -1,6 +1,8 @@
import { ValidatorType } from '../inputs/validation';
-export interface IValidationContext { [key: string]: unknown; }
+export interface IValidationContext {
+ [key: string]: unknown;
+}
type ValidatorMethod = (value: unknown, context?: IValidationContext) => ValidatedValue;
diff --git a/src/interfaces/workflow.ts b/src/interfaces/workflow.ts
index c060c938..16f3e30c 100644
--- a/src/interfaces/workflow.ts
+++ b/src/interfaces/workflow.ts
@@ -7,7 +7,6 @@ import { Scroller } from '../scroller';
export type OnDataChanged = (items: Item[]) => void;
-
export interface WorkflowParams {
datasource: IDatasource;
consumer: IPackage;
diff --git a/src/processes/adapter/append.ts b/src/processes/adapter/append.ts
index 18f27e3c..f576e07e 100644
--- a/src/processes/adapter/append.ts
+++ b/src/processes/adapter/append.ts
@@ -11,7 +11,6 @@ interface AppendRunOptions {
}
export default class Append extends BaseAdapterProcessFactory(AdapterProcess.append) {
-
static run(scroller: Scroller, { process, options }: AppendRunOptions): void {
const { params } = Append.parseInput(scroller, options, false, process);
if (!params) {
@@ -26,17 +25,24 @@ export default class Append extends BaseAdapterProcessFactory(AdapterProcess.app
});
}
- static doAppend(scroller: Scroller, process: AdapterProcess, params: AdapterAppendPrependOptions): boolean {
+ static doAppend(
+ scroller: Scroller,
+ process: AdapterProcess,
+ params: AdapterAppendPrependOptions
+ ): boolean {
const { bof, eof, increase, decrease } = params;
const { buffer } = scroller;
const prepend = process === AdapterProcess.prepend;
const opposite = prepend ? !increase : decrease;
- let beforeIndex, afterIndex, items = params.items;
+ let beforeIndex,
+ afterIndex,
+ items = params.items;
if (prepend) {
beforeIndex = (bof ? buffer.absMinIndex : buffer.minIndex) + (!buffer.size ? 1 : 0);
items = [...items].reverse();
} else {
- afterIndex = (eof ? buffer.absMaxIndex : buffer.maxIndex) - (!buffer.size && !opposite ? 1 : 0);
+ afterIndex =
+ (eof ? buffer.absMaxIndex : buffer.maxIndex) - (!buffer.size && !opposite ? 1 : 0);
}
return Insert.doInsert(scroller, {
items,
@@ -46,5 +52,4 @@ export default class Append extends BaseAdapterProcessFactory(AdapterProcess.app
virtualize: params.virtualize
});
}
-
}
diff --git a/src/processes/adapter/check.ts b/src/processes/adapter/check.ts
index 6ac99979..175ada97 100644
--- a/src/processes/adapter/check.ts
+++ b/src/processes/adapter/check.ts
@@ -3,10 +3,10 @@ import { BaseAdapterProcessFactory, AdapterProcess, ProcessStatus } from '../mis
import { Direction } from '../../inputs/index';
export default class Check extends BaseAdapterProcessFactory(AdapterProcess.check) {
-
static run(scroller: Scroller): void {
- const { workflow, buffer, state: { fetch }, viewport } = scroller;
- let min = Infinity, max = -Infinity;
+ const { workflow, buffer, state, viewport } = scroller;
+ let min = Infinity,
+ max = -Infinity;
buffer.items.forEach(item => {
const size = item.size;
@@ -19,16 +19,18 @@ export default class Check extends BaseAdapterProcessFactory(AdapterProcess.chec
});
if (Number.isFinite(min)) {
+ const { fetch } = state;
fetch.first.indexBuffer = buffer.firstIndex;
fetch.last.indexBuffer = buffer.lastIndex;
- const { index: firstIndex, diff } = viewport.getEdgeVisibleItem(buffer.items, Direction.backward);
+ const { index: firstIndex, diff } = viewport.getEdgeVisibleItem(
+ buffer.items,
+ Direction.backward
+ );
fetch.firstVisible.index = firstIndex;
if (!isNaN(firstIndex)) {
- fetch.firstVisible.delta = - buffer.getSizeByIndex(firstIndex) + diff;
+ fetch.firstVisible.delta = -buffer.getSizeByIndex(firstIndex) + diff;
}
- fetch.check(
- buffer.items.filter(item => item.$index >= min && item.$index <= max)
- );
+ fetch.check(buffer.items.filter(item => item.$index >= min && item.$index <= max));
}
scroller.logger.stat('check');
@@ -38,5 +40,4 @@ export default class Check extends BaseAdapterProcessFactory(AdapterProcess.chec
status: Number.isFinite(min) ? ProcessStatus.next : ProcessStatus.done
});
}
-
}
diff --git a/src/processes/adapter/clip.ts b/src/processes/adapter/clip.ts
index 31d9d3b0..8ba1adb7 100644
--- a/src/processes/adapter/clip.ts
+++ b/src/processes/adapter/clip.ts
@@ -3,7 +3,6 @@ import { BaseAdapterProcessFactory, AdapterProcess, ProcessStatus } from '../mis
import { AdapterClipOptions } from '../../interfaces/index';
export default class UserClip extends BaseAdapterProcessFactory(AdapterProcess.clip) {
-
static run(scroller: Scroller, options?: AdapterClipOptions): void {
const { params } = UserClip.parseInput(scroller, options);
@@ -15,5 +14,4 @@ export default class UserClip extends BaseAdapterProcessFactory(AdapterProcess.c
status: ProcessStatus.next
});
}
-
}
diff --git a/src/processes/adapter/fix.ts b/src/processes/adapter/fix.ts
index 04c56cad..87a97e14 100644
--- a/src/processes/adapter/fix.ts
+++ b/src/processes/adapter/fix.ts
@@ -5,13 +5,12 @@ import {
ItemsPredicate,
ItemsUpdater,
AdapterFixOptions,
- IValidatedData,
+ IValidatedData
} from '../../interfaces/index';
const { [AdapterProcess.fix]: FixParams } = AdapterMethods;
export default class Fix extends BaseAdapterProcessFactory(AdapterProcess.fix) {
-
static run(scroller: Scroller, options: AdapterFixOptions): void {
const { workflow } = scroller;
@@ -32,7 +31,12 @@ export default class Fix extends BaseAdapterProcessFactory(AdapterProcess.fix) {
});
}
- static runByType(scroller: Scroller, token: string, value: unknown, methodData: IValidatedData): void {
+ static runByType(
+ scroller: Scroller,
+ token: string,
+ value: unknown,
+ methodData: IValidatedData
+ ): void {
switch (token) {
case FixParams.scrollPosition:
return Fix.setScrollPosition(scroller, value as number);
@@ -45,7 +49,9 @@ export default class Fix extends BaseAdapterProcessFactory(AdapterProcess.fix) {
case FixParams.scrollToItem:
if (methodData.params) {
const scrollToItemOpt = methodData.params[FixParams.scrollToItemOpt];
- const options = scrollToItemOpt ? scrollToItemOpt.value as AdapterFixOptions['scrollToItemOpt'] : void 0;
+ const options = scrollToItemOpt
+ ? (scrollToItemOpt.value as AdapterFixOptions['scrollToItemOpt'])
+ : void 0;
return Fix.scrollToItem(scroller, value as ItemsPredicate, options);
}
return;
@@ -76,7 +82,7 @@ export default class Fix extends BaseAdapterProcessFactory(AdapterProcess.fix) {
static updateItems({ buffer, logger }: Scroller, value: ItemsUpdater): void {
let updateReference = false;
- const updater = () => updateReference = true;
+ const updater = () => (updateReference = true);
buffer.items.forEach(item => value(item.get(), updater));
if (updateReference) {
logger.log(() => 'update Buffer.items reference');
@@ -84,7 +90,11 @@ export default class Fix extends BaseAdapterProcessFactory(AdapterProcess.fix) {
}
}
- static scrollToItem(scroller: Scroller, value: ItemsPredicate, options?: boolean | ScrollIntoViewOptions): void {
+ static scrollToItem(
+ scroller: Scroller,
+ value: ItemsPredicate,
+ options?: boolean | ScrollIntoViewOptions
+ ): void {
const found = scroller.buffer.items.find(item => value(item.get()));
if (!found) {
scroller.logger.log(() => 'scrollToItem cancelled, item not found');
@@ -92,5 +102,4 @@ export default class Fix extends BaseAdapterProcessFactory(AdapterProcess.fix) {
}
found.scrollTo(options);
}
-
}
diff --git a/src/processes/adapter/insert.ts b/src/processes/adapter/insert.ts
index 4e07b23a..e7c54320 100644
--- a/src/processes/adapter/insert.ts
+++ b/src/processes/adapter/insert.ts
@@ -6,7 +6,6 @@ import { Direction } from '../../inputs/index';
import { AdapterInsertOptions, AdapterUpdateOptions } from '../../interfaces/index';
export default class Insert extends BaseAdapterProcessFactory(AdapterProcess.insert) {
-
static run(scroller: Scroller, options: AdapterInsertOptions): void {
const { params } = Insert.parseInput(scroller, options);
if (!params) {
@@ -32,25 +31,34 @@ export default class Insert extends BaseAdapterProcessFactory(AdapterProcess.ins
}
static insertEmpty(scroller: Scroller, params: AdapterInsertOptions): boolean {
- const { buffer, routines, state: { fetch } } = scroller;
+ const { buffer, routines, state } = scroller;
if (buffer.size) {
return false;
}
const { beforeIndex, afterIndex, items, decrease } = params;
- if (!buffer.fillEmpty(
- items, beforeIndex, afterIndex, !!decrease,
- (index, data) => new Item(index, data, routines)
- )) {
+ if (
+ !buffer.fillEmpty(
+ items,
+ beforeIndex,
+ afterIndex,
+ !!decrease,
+ (index, data) => new Item(index, data, routines)
+ )
+ ) {
return false;
}
- fetch.fill(buffer.items, buffer.startIndex);
+ state.fetch.fill(buffer.items, buffer.startIndex);
return true;
}
static insertInBuffer(scroller: Scroller, params: AdapterInsertOptions): boolean {
const { before, after, beforeIndex, afterIndex, items, decrease } = params;
- const indexToInsert = scroller.buffer.getIndexToInsert(before || after, beforeIndex, afterIndex);
+ const indexToInsert = scroller.buffer.getIndexToInsert(
+ before || after,
+ beforeIndex,
+ afterIndex
+ );
if (params.virtualize || isNaN(indexToInsert)) {
return false;
@@ -72,7 +80,7 @@ export default class Insert extends BaseAdapterProcessFactory(AdapterProcess.ins
static insertVirtually(scroller: Scroller, params: AdapterInsertOptions): boolean {
const { beforeIndex, afterIndex, items, decrease } = params;
- const { buffer, state: { fetch }, viewport } = scroller;
+ const { buffer, state, viewport } = scroller;
const direction = Number.isInteger(beforeIndex) ? Direction.backward : Direction.forward;
const indexToInsert = (direction === Direction.backward ? beforeIndex : afterIndex) as number;
@@ -80,14 +88,14 @@ export default class Insert extends BaseAdapterProcessFactory(AdapterProcess.ins
return false;
}
+ const { fetch } = state;
const { index, diff } = viewport.getEdgeVisibleItem(buffer.items, Direction.backward);
fetch.firstVisible.index = index;
if (!isNaN(index)) {
fetch.simulate = true;
- fetch.firstVisible.delta = - buffer.getSizeByIndex(index) + diff;
+ fetch.firstVisible.delta = -buffer.getSizeByIndex(index) + diff;
}
return true;
}
-
}
diff --git a/src/processes/adapter/pause.ts b/src/processes/adapter/pause.ts
index f37606fe..e304f95c 100644
--- a/src/processes/adapter/pause.ts
+++ b/src/processes/adapter/pause.ts
@@ -2,7 +2,6 @@ import { Scroller } from '../../scroller';
import { BaseAdapterProcessFactory, AdapterProcess, ProcessStatus } from '../misc/index';
export default class Pause extends BaseAdapterProcessFactory(AdapterProcess.pause) {
-
static run(scroller: Scroller, options?: { resume: boolean }): void {
const resume = !!options?.resume;
@@ -24,5 +23,4 @@ export default class Pause extends BaseAdapterProcessFactory(AdapterProcess.paus
status: ProcessStatus.next
});
}
-
}
diff --git a/src/processes/adapter/reload.ts b/src/processes/adapter/reload.ts
index beafa8b0..bfb6f7b9 100644
--- a/src/processes/adapter/reload.ts
+++ b/src/processes/adapter/reload.ts
@@ -3,7 +3,6 @@ import { BaseAdapterProcessFactory, AdapterProcess, ProcessStatus } from '../mis
import { ProcessPayload } from '../../interfaces/index';
export default class Reload extends BaseAdapterProcessFactory(AdapterProcess.reload) {
-
static run(scroller: Scroller, reloadIndex: number): void {
const { viewport, state, buffer } = scroller;
@@ -24,5 +23,4 @@ export default class Reload extends BaseAdapterProcessFactory(AdapterProcess.rel
payload
});
}
-
}
diff --git a/src/processes/adapter/remove.ts b/src/processes/adapter/remove.ts
index 56083609..322ca69b 100644
--- a/src/processes/adapter/remove.ts
+++ b/src/processes/adapter/remove.ts
@@ -5,7 +5,6 @@ import { Direction } from '../../inputs/index';
import { AdapterRemoveOptions, AdapterUpdateOptions, ItemsPredicate } from '../../interfaces/index';
export default class Remove extends BaseAdapterProcessFactory(AdapterProcess.remove) {
-
static run(scroller: Scroller, options: AdapterRemoveOptions): void {
const { params } = Remove.parseInput(scroller, options);
if (!params) {
@@ -33,8 +32,8 @@ export default class Remove extends BaseAdapterProcessFactory(AdapterProcess.rem
if (params.indexes && params.indexes.length) {
const diffLeft = (params.increase ? 1 : 0) * removed.length;
const diffRight = (params.increase ? 0 : -1) * removed.length;
- params.indexes = params.indexes.map(index =>
- index + (index < removed[0] ? diffLeft : diffRight)
+ params.indexes = params.indexes.map(
+ index => index + (index < removed[0] ? diffLeft : diffRight)
);
}
}
@@ -52,11 +51,11 @@ export default class Remove extends BaseAdapterProcessFactory(AdapterProcess.rem
return [];
}
const newPredicate: ItemsPredicate = item =>
- (predicate && predicate(item)) ||
- (!!indexes && indexes.includes(item.$index));
+ (predicate && predicate(item)) || (!!indexes && indexes.includes(item.$index));
- const indexesToRemove: number[] = scroller.buffer.items.reduce((acc, item) =>
- newPredicate(item) ? [...acc, item.$index] : acc, [] as number[]
+ const indexesToRemove: number[] = scroller.buffer.items.reduce(
+ (acc, item) => (newPredicate(item) ? [...acc, item.$index] : acc),
+ [] as number[]
);
const updateOptions: AdapterUpdateOptions = {
predicate: item => !newPredicate(item),
@@ -71,7 +70,7 @@ export default class Remove extends BaseAdapterProcessFactory(AdapterProcess.rem
if (!indexes || !indexes.length) {
return false;
}
- const { buffer, viewport, state: { fetch } } = scroller;
+ const { buffer, viewport, state } = scroller;
// get items to remove
const { finiteAbsMinIndex, firstIndex, finiteAbsMaxIndex, lastIndex } = buffer;
@@ -92,11 +91,12 @@ export default class Remove extends BaseAdapterProcessFactory(AdapterProcess.rem
}
// what should be shown after remove; Buffer removal has priority
+ const { fetch } = state;
if (isNaN(fetch.firstVisible.index)) {
const { index, diff } = viewport.getEdgeVisibleItem(buffer.items, Direction.backward);
fetch.firstVisible.index = index;
if (!isNaN(index)) {
- fetch.firstVisible.delta = - buffer.getSizeByIndex(index) + diff;
+ fetch.firstVisible.delta = -buffer.getSizeByIndex(index) + diff;
}
}
@@ -109,15 +109,23 @@ export default class Remove extends BaseAdapterProcessFactory(AdapterProcess.rem
return true;
}
- static shiftFirstVisibleIndex(scroller: Scroller, listToRemove: number[], increase: boolean): void {
+ static shiftFirstVisibleIndex(
+ scroller: Scroller,
+ listToRemove: number[],
+ increase: boolean
+ ): void {
const { firstVisible } = scroller.state.fetch;
if (isNaN(firstVisible.index)) {
return;
}
- const shift = listToRemove.reduce((acc, index) => acc + (
- ((increase && index > firstVisible.index) || (!increase && index < firstVisible.index)) ? 1 : 0
- ), 0);
+ const shift = listToRemove.reduce(
+ (acc, index) =>
+ acc +
+ ((increase && index > firstVisible.index) || (!increase && index < firstVisible.index)
+ ? 1
+ : 0),
+ 0
+ );
firstVisible.index = firstVisible.index + (increase ? shift : -shift);
}
-
}
diff --git a/src/processes/adapter/replace.ts b/src/processes/adapter/replace.ts
index 5c9bd8a6..4d202447 100644
--- a/src/processes/adapter/replace.ts
+++ b/src/processes/adapter/replace.ts
@@ -4,7 +4,6 @@ import { BaseAdapterProcessFactory, AdapterProcess, ProcessStatus } from '../mis
import { AdapterReplaceOptions, AdapterUpdateOptions } from '../../interfaces/index';
export default class Replace extends BaseAdapterProcessFactory(AdapterProcess.replace) {
-
static run(scroller: Scroller, options: AdapterReplaceOptions): void {
const { params } = Replace.parseInput(scroller, options);
if (!params) {
@@ -14,7 +13,7 @@ export default class Replace extends BaseAdapterProcessFactory(AdapterProcess.re
scroller.workflow.call({
process: Replace.process,
- status: shouldReplace ? ProcessStatus.next : ProcessStatus.done,
+ status: shouldReplace ? ProcessStatus.next : ProcessStatus.done
});
}
@@ -45,5 +44,4 @@ export default class Replace extends BaseAdapterProcessFactory(AdapterProcess.re
return Update.doUpdate(scroller, updateOptions);
}
-
}
diff --git a/src/processes/adapter/reset.ts b/src/processes/adapter/reset.ts
index c5e0e618..77f2935d 100644
--- a/src/processes/adapter/reset.ts
+++ b/src/processes/adapter/reset.ts
@@ -5,10 +5,8 @@ import { BaseAdapterProcessFactory, AdapterProcess, ProcessStatus } from '../mis
import { IDatasourceOptional, ProcessPayload } from '../../interfaces/index';
export default class Reset extends BaseAdapterProcessFactory(AdapterProcess.reset) {
-
static run(scroller: Scroller, options?: IDatasourceOptional): void {
- const { datasource, buffer, viewport: { paddings }, state: { cycle } } = scroller;
-
+ const { datasource, buffer, viewport, state } = scroller;
if (options) {
const { data } = Reset.parseInput(scroller, options);
if (!data.isValid) {
@@ -25,13 +23,13 @@ export default class Reset extends BaseAdapterProcessFactory(AdapterProcess.rese
}
buffer.reset(true);
- paddings.backward.reset();
- paddings.forward.reset();
+ viewport.paddings.backward.reset();
+ viewport.paddings.forward.reset();
const payload: ProcessPayload = { datasource };
- if (cycle.busy.get()) {
+ if (state.cycle.busy.get()) {
payload.finalize = true;
- cycle.interrupter = Reset.process;
+ state.cycle.interrupter = Reset.process;
}
scroller.workflow.call({
@@ -40,5 +38,4 @@ export default class Reset extends BaseAdapterProcessFactory(AdapterProcess.rese
payload
});
}
-
}
diff --git a/src/processes/adapter/update.ts b/src/processes/adapter/update.ts
index b6fa7035..b4fc69b1 100644
--- a/src/processes/adapter/update.ts
+++ b/src/processes/adapter/update.ts
@@ -5,7 +5,6 @@ import { Direction } from '../../inputs/index';
import { AdapterUpdateOptions } from '../../interfaces/index';
export default class Update extends BaseAdapterProcessFactory(AdapterProcess.update) {
-
static run(scroller: Scroller, options: AdapterUpdateOptions): void {
const { params } = Update.parseInput(scroller, options);
if (!params) {
@@ -21,13 +20,16 @@ export default class Update extends BaseAdapterProcessFactory(AdapterProcess.upd
}
static doUpdate(scroller: Scroller, params: AdapterUpdateOptions): boolean {
- const { buffer, viewport, state: { fetch }, routines, logger } = scroller;
+ const { buffer, viewport, state, routines, logger } = scroller;
if (!buffer.items) {
logger.log(() => 'no items in Buffer');
return false;
}
- const { item: firstItem, index: firstIndex, diff: firstItemDiff } =
- viewport.getEdgeVisibleItem(buffer.items, Direction.backward);
+ const {
+ item: firstItem,
+ index: firstIndex,
+ diff: firstItemDiff
+ } = viewport.getEdgeVisibleItem(buffer.items, Direction.backward);
const { trackedIndex, toRemove } = buffer.updateItems(
params.predicate,
@@ -39,26 +41,28 @@ export default class Update extends BaseAdapterProcessFactory(AdapterProcess.upd
let delta = 0;
const trackedItem = buffer.get(trackedIndex);
if (firstItem && firstItem === trackedItem) {
- delta = - buffer.getSizeByIndex(trackedIndex) + firstItemDiff;
+ delta = -buffer.getSizeByIndex(trackedIndex) + firstItemDiff;
}
toRemove.forEach(item => item.hide());
- logger.log(() => toRemove.length
- ? 'items to remove: [' + toRemove.map(({ $index }) => $index).join(',') + ']'
- : 'no items to remove'
+ logger.log(() =>
+ toRemove.length
+ ? 'items to remove: [' + toRemove.map(({ $index }) => $index).join(',') + ']'
+ : 'no items to remove'
);
- if (toRemove.length) { // insertions will be processed on render
+ if (toRemove.length) {
+ // insertions will be processed on render
buffer.checkDefaultSize();
}
const toRender = buffer.items.filter(({ toInsert }) => toInsert);
- logger.log(() => toRender.length
- ? 'items to render: [' + toRender.map(({ $index }) => $index).join(',') + ']'
- : 'no items to render'
+ logger.log(() =>
+ toRender.length
+ ? 'items to render: [' + toRender.map(({ $index }) => $index).join(',') + ']'
+ : 'no items to render'
);
- fetch.update(trackedIndex, delta, toRender, toRemove);
+ state.fetch.update(trackedIndex, delta, toRender, toRemove);
return !!toRemove.length || !!toRender.length;
}
-
}
diff --git a/src/processes/adjust.ts b/src/processes/adjust.ts
index 30001fcc..e8b063f2 100644
--- a/src/processes/adjust.ts
+++ b/src/processes/adjust.ts
@@ -1,164 +1,171 @@
-import { BaseProcessFactory, CommonProcess, ProcessStatus } from './misc/index';
-import { Scroller } from '../scroller';
-import End from './end';
-
-export default class Adjust extends BaseProcessFactory(CommonProcess.adjust) {
-
- static run(scroller: Scroller): void {
- const { workflow, viewport, state: { scroll } } = scroller;
-
- scroll.positionBeforeAdjust = viewport.scrollPosition;
- Adjust.setPaddings(scroller);
- scroll.positionAfterAdjust = viewport.scrollPosition;
-
- // scroll position adjustments
- const position = Adjust.calculatePosition(scroller);
-
- // additional adjustment if the position can't be reached during the initial cycle
- Adjust.setAdditionalForwardPadding(scroller, position);
-
- // set new position using animation frame
- Adjust.setPosition(scroller, position, () =>
- workflow.call({
- process: Adjust.process,
- status: ProcessStatus.done
- })
- );
- }
-
- static setPaddings(scroller: Scroller): void {
- const { viewport, buffer, settings: { inverse }, state: { fetch } } = scroller;
- const firstItem = buffer.getFirstVisibleItem();
- const lastItem = buffer.getLastVisibleItem();
- let first, last;
- if (firstItem && lastItem) {
- first = firstItem.$index;
- last = lastItem.$index;
- } else {
- first = !isNaN(fetch.firstVisible.index) ? fetch.firstVisible.index : buffer.startIndex;
- last = first - 1;
- }
- const { forward, backward } = viewport.paddings;
- let index, bwdSize = 0, fwdSize = 0;
-
- // new backward and forward paddings size
- for (index = buffer.finiteAbsMinIndex; index < first; index++) {
- bwdSize += buffer.getSizeByIndex(index);
- }
- for (index = last + 1; index <= buffer.finiteAbsMaxIndex; index++) {
- fwdSize += buffer.getSizeByIndex(index);
- }
-
- // lack of items case
- const bufferSize = viewport.getScrollableSize() - forward.size - backward.size;
- const scrollSize = bwdSize + bufferSize + fwdSize;
- const viewportSizeDiff = viewport.getSize() - scrollSize;
- if (viewportSizeDiff > 0) {
- if (inverse) {
- bwdSize += viewportSizeDiff;
- } else {
- fwdSize += viewportSizeDiff;
- }
- scroller.logger.log(() =>
- inverse ? 'backward' : 'forward' + ` padding will be increased by ${viewportSizeDiff} to fill the viewport`
- );
- }
-
- backward.size = bwdSize;
- forward.size = fwdSize;
-
- scroller.logger.stat('after paddings adjustments');
- }
-
- static calculatePosition(scroller: Scroller): number {
- const { viewport, buffer, state: { fetch, render, scroll } } = scroller;
- let position = viewport.paddings.backward.size;
-
- // increase the position to meet the expectation of the first visible item
- if (!isNaN(fetch.firstVisible.index) && !isNaN(buffer.firstIndex)) {
- scroller.logger.log(`first index = ${fetch.firstVisible.index}, delta = ${fetch.firstVisible.delta}`);
- const shouldCheckPreSizeExpectation = fetch.shouldCheckPreSizeExpectation(buffer.lastIndex);
- buffer.items.forEach(item => {
- // 1) shift of the buffered items before the first visible item
- if (item.$index < fetch.firstVisible.index) {
- position += item.size;
- return;
- }
- // 2) delta of the first visible item
- if (item.$index === fetch.firstVisible.index && fetch.firstVisible.delta) {
- position -= fetch.firstVisible.delta;
- }
- // 3) difference between expected and real sizes of fetched items after the first visible
- if (shouldCheckPreSizeExpectation && item.preSize && fetch.items.includes(item)) {
- position += item.size - item.preSize;
- }
- });
- }
-
- // slow fetch/render case
- if (scroll.positionBeforeAsync !== null) {
- const diff = render.positionBefore - scroll.positionBeforeAsync;
- if (diff !== 0) {
- scroller.logger.log(`shift position due to fetch-render difference (${diff})`);
- position += diff;
- }
- }
-
- // increase the position due to viewport's offset
- if (viewport.offset > 0 && (position || fetch.positions.before)) {
- position += viewport.offset;
- }
-
- return Math.round(position);
- }
-
- static setAdditionalForwardPadding(scroller: Scroller, position: number): void {
- const { viewport, buffer, state: { cycle } } = scroller;
- if (!cycle.isInitial || !End.shouldContinueRun(scroller, null)) {
- return;
- }
- const diff = position - viewport.getMaxScrollPosition();
- if (diff <= 0) {
- return;
- }
- const last = buffer.getLastVisibleItem();
- if (!last) {
- return;
- }
- let size = 0;
- let index = last.$index + 1;
- while (size <= diff && index <= buffer.absMaxIndex) {
- size += buffer.getSizeByIndex(index++);
- }
- const shift = Math.min(size, diff);
- if (shift) {
- viewport.paddings.forward.size += shift;
- scroller.logger.log(`increase fwd padding due to lack of items (${diff} -> ${shift})`);
- }
- }
-
- static setPosition(scroller: Scroller, position: number, done: () => void): void {
- const { state: { scroll }, viewport, routines } = scroller;
- if (!scroll.hasPositionChanged(position)) {
- return done();
- }
- scroll.syntheticPosition = position;
- scroll.syntheticFulfill = false;
-
- scroll.cancelAnimation = routines.animate(() => {
- scroll.cancelAnimation = null;
- const inertiaDiff = (scroll.positionAfterAdjust as number) - viewport.scrollPosition;
- let diffLog = '';
- if (inertiaDiff > 0) {
- position -= inertiaDiff;
- scroll.syntheticPosition = position;
- diffLog = ` (-${inertiaDiff})`;
- }
- scroll.syntheticFulfill = true;
- viewport.scrollPosition = position;
- scroller.logger.stat('after scroll adjustment' + diffLog);
- done();
- });
- }
-
-}
+import { BaseProcessFactory, CommonProcess, ProcessStatus } from './misc/index';
+import { Scroller } from '../scroller';
+import End from './end';
+
+export default class Adjust extends BaseProcessFactory(CommonProcess.adjust) {
+ static run(scroller: Scroller): void {
+ const { workflow, viewport, state } = scroller;
+
+ state.scroll.positionBeforeAdjust = viewport.scrollPosition;
+ Adjust.setPaddings(scroller);
+ state.scroll.positionAfterAdjust = viewport.scrollPosition;
+
+ // scroll position adjustments
+ const position = Adjust.calculatePosition(scroller);
+
+ // additional adjustment if the position can't be reached during the initial cycle
+ Adjust.setAdditionalForwardPadding(scroller, position);
+
+ // set new position using animation frame
+ Adjust.setPosition(scroller, position, () =>
+ workflow.call({
+ process: Adjust.process,
+ status: ProcessStatus.done
+ })
+ );
+ }
+
+ static setPaddings(scroller: Scroller): void {
+ const { viewport, buffer, settings, state } = scroller;
+ const firstItem = buffer.getFirstVisibleItem();
+ const lastItem = buffer.getLastVisibleItem();
+ let first, last;
+ if (firstItem && lastItem) {
+ first = firstItem.$index;
+ last = lastItem.$index;
+ } else {
+ const { fetch } = state;
+ first = !isNaN(fetch.firstVisible.index) ? fetch.firstVisible.index : buffer.startIndex;
+ last = first - 1;
+ }
+ const { forward, backward } = viewport.paddings;
+ let index,
+ bwdSize = 0,
+ fwdSize = 0;
+
+ // new backward and forward paddings size
+ for (index = buffer.finiteAbsMinIndex; index < first; index++) {
+ bwdSize += buffer.getSizeByIndex(index);
+ }
+ for (index = last + 1; index <= buffer.finiteAbsMaxIndex; index++) {
+ fwdSize += buffer.getSizeByIndex(index);
+ }
+
+ // lack of items case
+ const bufferSize = viewport.getScrollableSize() - forward.size - backward.size;
+ const scrollSize = bwdSize + bufferSize + fwdSize;
+ const viewportSizeDiff = viewport.getSize() - scrollSize;
+ if (viewportSizeDiff > 0) {
+ if (settings.inverse) {
+ bwdSize += viewportSizeDiff;
+ } else {
+ fwdSize += viewportSizeDiff;
+ }
+ scroller.logger.log(() =>
+ settings.inverse
+ ? 'backward'
+ : 'forward' + ` padding will be increased by ${viewportSizeDiff} to fill the viewport`
+ );
+ }
+
+ backward.size = bwdSize;
+ forward.size = fwdSize;
+
+ scroller.logger.stat('after paddings adjustments');
+ }
+
+ static calculatePosition(scroller: Scroller): number {
+ const { viewport, buffer, state } = scroller;
+ const { fetch, render, scroll } = state;
+ let position = viewport.paddings.backward.size;
+
+ // increase the position to meet the expectation of the first visible item
+ if (!isNaN(fetch.firstVisible.index) && !isNaN(buffer.firstIndex)) {
+ scroller.logger.log(
+ `first index = ${fetch.firstVisible.index}, delta = ${fetch.firstVisible.delta}`
+ );
+ const shouldCheckPreSizeExpectation = fetch.shouldCheckPreSizeExpectation(buffer.lastIndex);
+ buffer.items.forEach(item => {
+ // 1) shift of the buffered items before the first visible item
+ if (item.$index < fetch.firstVisible.index) {
+ position += item.size;
+ return;
+ }
+ // 2) delta of the first visible item
+ if (item.$index === fetch.firstVisible.index && fetch.firstVisible.delta) {
+ position -= fetch.firstVisible.delta;
+ }
+ // 3) difference between expected and real sizes of fetched items after the first visible
+ if (shouldCheckPreSizeExpectation && item.preSize && fetch.items.includes(item)) {
+ position += item.size - item.preSize;
+ }
+ });
+ }
+
+ // slow fetch/render case
+ if (scroll.positionBeforeAsync !== null) {
+ const diff = render.positionBefore - scroll.positionBeforeAsync;
+ if (diff !== 0) {
+ scroller.logger.log(`shift position due to fetch-render difference (${diff})`);
+ position += diff;
+ }
+ }
+
+ // increase the position due to viewport's offset
+ if (viewport.offset > 0 && (position || fetch.positions.before)) {
+ position += viewport.offset;
+ }
+
+ return Math.round(position);
+ }
+
+ static setAdditionalForwardPadding(scroller: Scroller, position: number): void {
+ const { viewport, buffer, state } = scroller;
+ if (!state.cycle.isInitial || !End.shouldContinueRun(scroller, null)) {
+ return;
+ }
+ const diff = position - viewport.getMaxScrollPosition();
+ if (diff <= 0) {
+ return;
+ }
+ const last = buffer.getLastVisibleItem();
+ if (!last) {
+ return;
+ }
+ let size = 0;
+ let index = last.$index + 1;
+ while (size <= diff && index <= buffer.absMaxIndex) {
+ size += buffer.getSizeByIndex(index++);
+ }
+ const shift = Math.min(size, diff);
+ if (shift) {
+ viewport.paddings.forward.size += shift;
+ scroller.logger.log(`increase fwd padding due to lack of items (${diff} -> ${shift})`);
+ }
+ }
+
+ static setPosition(scroller: Scroller, position: number, done: () => void): void {
+ const { state, viewport, routines } = scroller;
+ const { scroll } = state;
+ if (!scroll.hasPositionChanged(position)) {
+ return done();
+ }
+ scroll.syntheticPosition = position;
+ scroll.syntheticFulfill = false;
+
+ scroll.cancelAnimation = routines.animate(() => {
+ scroll.cancelAnimation = null;
+ const inertiaDiff = (scroll.positionAfterAdjust as number) - viewport.scrollPosition;
+ let diffLog = '';
+ if (inertiaDiff > 0) {
+ position -= inertiaDiff;
+ scroll.syntheticPosition = position;
+ diffLog = ` (-${inertiaDiff})`;
+ }
+ scroll.syntheticFulfill = true;
+ viewport.scrollPosition = position;
+ scroller.logger.stat('after scroll adjustment' + diffLog);
+ done();
+ });
+ }
+}
diff --git a/src/processes/clip.ts b/src/processes/clip.ts
index d9877f75..0447f5c6 100644
--- a/src/processes/clip.ts
+++ b/src/processes/clip.ts
@@ -1,62 +1,60 @@
-import { BaseProcessFactory, CommonProcess, ProcessStatus } from './misc/index';
-import { Scroller } from '../scroller';
-import { Direction } from '../inputs/index';
-
-export default class Clip extends BaseProcessFactory(CommonProcess.clip) {
-
- static run(scroller: Scroller): void {
- const { workflow } = scroller;
-
- Clip.doClip(scroller);
-
- workflow.call({
- process: Clip.process,
- status: ProcessStatus.next
- });
- }
-
- static doClip(scroller: Scroller): void {
- const { buffer, viewport: { paddings }, state: { clip }, logger } = scroller;
- const size = { [Direction.backward]: 0, [Direction.forward]: 0 };
-
- logger.stat(`before clip (${++clip.callCount})`);
-
- const itemsToRemove = buffer.items.filter(item => {
- if (!item.toRemove) {
- return false;
- }
- item.hide();
- size[item.removeDirection] += item.size;
- return true;
- });
-
- if (itemsToRemove.length) {
- if (size[Direction.backward]) {
- paddings.byDirection(Direction.backward).size += size[Direction.backward];
- }
- if (size[Direction.forward]) {
- paddings.byDirection(Direction.forward).size += size[Direction.forward];
- }
- if (scroller.settings.onBeforeClip) {
- scroller.settings.onBeforeClip(itemsToRemove.map(item => item.get()));
- }
- }
-
- buffer.clip();
-
- logger.log(() => {
- const list = itemsToRemove.map(({ $index }) => $index);
- return list.length
- ? [
- `clipped ${list.length} item(s) from Buffer` +
- (size.backward ? `, +${size.backward} fwd px` : '') +
- (size.forward ? `, +${size.forward} bwd px` : '') +
- `, range: [${list[0]}..${list[list.length - 1]}]`
- ]
- : 'clipped 0 items from Buffer';
- });
-
- logger.stat('after clip');
- }
-
-}
+import { BaseProcessFactory, CommonProcess, ProcessStatus } from './misc/index';
+import { Scroller } from '../scroller';
+import { Direction } from '../inputs/index';
+
+export default class Clip extends BaseProcessFactory(CommonProcess.clip) {
+ static run(scroller: Scroller): void {
+ const { workflow } = scroller;
+
+ Clip.doClip(scroller);
+
+ workflow.call({
+ process: Clip.process,
+ status: ProcessStatus.next
+ });
+ }
+
+ static doClip(scroller: Scroller): void {
+ const { buffer, viewport, state, logger } = scroller;
+ const size = { [Direction.backward]: 0, [Direction.forward]: 0 };
+
+ logger.stat(`before clip (${++state.clip.callCount})`);
+
+ const itemsToRemove = buffer.items.filter(item => {
+ if (!item.toRemove) {
+ return false;
+ }
+ item.hide();
+ size[item.removeDirection] += item.size;
+ return true;
+ });
+
+ if (itemsToRemove.length) {
+ if (size[Direction.backward]) {
+ viewport.paddings.byDirection(Direction.backward).size += size[Direction.backward];
+ }
+ if (size[Direction.forward]) {
+ viewport.paddings.byDirection(Direction.forward).size += size[Direction.forward];
+ }
+ if (scroller.settings.onBeforeClip) {
+ scroller.settings.onBeforeClip(itemsToRemove.map(item => item.get()));
+ }
+ }
+
+ buffer.clip();
+
+ logger.log(() => {
+ const list = itemsToRemove.map(({ $index }) => $index);
+ return list.length
+ ? [
+ `clipped ${list.length} item(s) from Buffer` +
+ (size.backward ? `, +${size.backward} fwd px` : '') +
+ (size.forward ? `, +${size.forward} bwd px` : '') +
+ `, range: [${list[0]}..${list[list.length - 1]}]`
+ ]
+ : 'clipped 0 items from Buffer';
+ });
+
+ logger.stat('after clip');
+ }
+}
diff --git a/src/processes/end.ts b/src/processes/end.ts
index ff1a80d2..7bbc1152 100644
--- a/src/processes/end.ts
+++ b/src/processes/end.ts
@@ -5,9 +5,9 @@ import { ScrollerWorkflow } from '../interfaces/index';
const isInterrupted = ({ call }: ScrollerWorkflow): boolean => !!call.interrupted;
export default class End extends BaseProcessFactory(CommonProcess.end) {
-
static run(scroller: Scroller, { error }: { error?: unknown } = {}): void {
- const { workflow, state: { cycle: { interrupter } } } = scroller;
+ const { workflow, state } = scroller;
+ const { interrupter } = state.cycle;
if (!error && !interrupter) {
// set out params accessible via Adapter
@@ -61,5 +61,4 @@ export default class End extends BaseProcessFactory(CommonProcess.end) {
}
return false;
}
-
}
diff --git a/src/processes/fetch.ts b/src/processes/fetch.ts
index 9f1b6cd7..4171e661 100644
--- a/src/processes/fetch.ts
+++ b/src/processes/fetch.ts
@@ -16,15 +16,15 @@ interface FetchBox {
}
export default class Fetch extends BaseProcessFactory(CommonProcess.fetch) {
-
static run(scroller: Scroller): void {
const { workflow } = scroller;
const box = {
success: (data: unknown[]) => {
- scroller.logger.log(() =>
- `resolved ${data.length} items ` +
- `(index = ${scroller.state.fetch.index}, count = ${scroller.state.fetch.count})`
+ scroller.logger.log(
+ () =>
+ `resolved ${data.length} items ` +
+ `(index = ${scroller.state.fetch.index}, count = ${scroller.state.fetch.count})`
);
scroller.state.fetch.newItemsData = data;
workflow.call({
@@ -53,7 +53,8 @@ export default class Fetch extends BaseProcessFactory(CommonProcess.fetch) {
box.fail(error);
}
} else {
- const { state: { scroll, fetch }, viewport } = scroller;
+ const { state, viewport } = scroller;
+ const { scroll, fetch } = state;
if (scroll.positionBeforeAsync === null) {
scroll.positionBeforeAsync = viewport.scrollPosition;
}
@@ -62,8 +63,8 @@ export default class Fetch extends BaseProcessFactory(CommonProcess.fetch) {
box.fail = () => null;
};
(result as Promise).then(
- (data) => box.success(data),
- (error) => box.fail(error)
+ data => box.success(data),
+ error => box.fail(error)
);
}
}
@@ -105,9 +106,10 @@ export default class Fetch extends BaseProcessFactory(CommonProcess.fetch) {
}
}
- if (immediateData || immediateError) { // callback case or immediate observable
+ if (immediateData || immediateError) {
+ // callback case or immediate observable
return {
- data: immediateError ? null : (immediateData || []),
+ data: immediateError ? null : immediateData || [],
error: immediateError,
isError: !!immediateError
};
@@ -118,5 +120,4 @@ export default class Fetch extends BaseProcessFactory(CommonProcess.fetch) {
reject = _reject;
});
}
-
}
diff --git a/src/processes/index.ts b/src/processes/index.ts
index 9bc0ebb3..f3dafed3 100644
--- a/src/processes/index.ts
+++ b/src/processes/index.ts
@@ -1,31 +1,52 @@
-import Init from './init';
-import Scroll from './scroll';
-import Reset from './adapter/reset';
-import Reload from './adapter/reload';
-import Append from './adapter/append';
-import Check from './adapter/check';
-import Remove from './adapter/remove';
-import UserClip from './adapter/clip';
-import Insert from './adapter/insert';
-import Replace from './adapter/replace';
-import Update from './adapter/update';
-import Pause from './adapter/pause';
-import Fix from './adapter/fix';
-import Start from './start';
-import PreFetch from './preFetch';
-import Fetch from './fetch';
-import PostFetch from './postFetch';
-import Render from './render';
-import Adjust from './adjust';
-import PreClip from './preClip';
-import Clip from './clip';
-import End from './end';
-
-import { CommonProcess, AdapterProcess, ProcessStatus } from './misc/enums';
-
-export {
- Init, Scroll,
- Reset, Reload, Append, Check, Remove, UserClip, Insert, Replace, Update, Pause, Fix,
- Start, PreFetch, Fetch, PostFetch, Render, PreClip, Clip, Adjust, End,
- CommonProcess, AdapterProcess, ProcessStatus,
-};
+import Init from './init';
+import Scroll from './scroll';
+import Reset from './adapter/reset';
+import Reload from './adapter/reload';
+import Append from './adapter/append';
+import Check from './adapter/check';
+import Remove from './adapter/remove';
+import UserClip from './adapter/clip';
+import Insert from './adapter/insert';
+import Replace from './adapter/replace';
+import Update from './adapter/update';
+import Pause from './adapter/pause';
+import Fix from './adapter/fix';
+import Start from './start';
+import PreFetch from './preFetch';
+import Fetch from './fetch';
+import PostFetch from './postFetch';
+import Render from './render';
+import Adjust from './adjust';
+import PreClip from './preClip';
+import Clip from './clip';
+import End from './end';
+
+import { CommonProcess, AdapterProcess, ProcessStatus } from './misc/enums';
+
+export {
+ Init,
+ Scroll,
+ Reset,
+ Reload,
+ Append,
+ Check,
+ Remove,
+ UserClip,
+ Insert,
+ Replace,
+ Update,
+ Pause,
+ Fix,
+ Start,
+ PreFetch,
+ Fetch,
+ PostFetch,
+ Render,
+ PreClip,
+ Clip,
+ Adjust,
+ End,
+ CommonProcess,
+ AdapterProcess,
+ ProcessStatus
+};
diff --git a/src/processes/init.ts b/src/processes/init.ts
index e93a6750..313f73fa 100644
--- a/src/processes/init.ts
+++ b/src/processes/init.ts
@@ -5,7 +5,6 @@ import { ProcessName } from '../interfaces/index';
const initProcesses = [CommonProcess.init, AdapterProcess.reset, AdapterProcess.reload];
export default class Init extends BaseProcessFactory(CommonProcess.init) {
-
static run(scroller: Scroller, process: ProcessName): void {
const { state, workflow } = scroller;
const isInitial = initProcesses.includes(process);
@@ -16,5 +15,4 @@ export default class Init extends BaseProcessFactory(CommonProcess.init) {
status: ProcessStatus.next
});
}
-
}
diff --git a/src/processes/misc/base.ts b/src/processes/misc/base.ts
index 3f96d679..d75fc176 100644
--- a/src/processes/misc/base.ts
+++ b/src/processes/misc/base.ts
@@ -1,35 +1,40 @@
import { AdapterProcess, ProcessStatus } from './enums';
import { Scroller } from '../../scroller';
import { ADAPTER_METHODS, validate } from '../../inputs/index';
-import { ProcessName, IBaseProcess, IBaseAdapterProcess, IAdapterInput } from '../../interfaces/index';
+import {
+ ProcessName,
+ IBaseProcess,
+ IBaseAdapterProcess,
+ IAdapterInput
+} from '../../interfaces/index';
export const BaseProcessFactory = (process: ProcessName): IBaseProcess =>
-
class BaseProcess {
-
static process: ProcessName = process;
-
};
export const BaseAdapterProcessFactory = (process: AdapterProcess): IBaseAdapterProcess =>
-
class BaseAdapterProcess extends (BaseProcessFactory(process) as IBaseProcess) {
-
static process: AdapterProcess = process;
static parseInput(
- scroller: Scroller, options: T, ignoreErrors = false, _process?: AdapterProcess
+ scroller: Scroller,
+ options: T,
+ ignoreErrors = false,
+ _process?: AdapterProcess
): IAdapterInput {
const result: IAdapterInput = {
data: validate(options, ADAPTER_METHODS[_process || process])
};
if (result.data.isValid) {
- result.params = Object.entries(result.data.params)
- .reduce((acc, [key, { value }]) => ({
+ result.params = Object.entries(result.data.params).reduce(
+ (acc, [key, { value }]) => ({
...acc,
[key]: value
- }), {} as T);
+ }),
+ {} as T
+ );
} else {
scroller.logger.log(() => result.data.showErrors());
if (!ignoreErrors) {
@@ -43,5 +48,4 @@ export const BaseAdapterProcessFactory = (process: AdapterProcess): IBaseAdapter
return result;
}
-
};
diff --git a/src/processes/misc/enums.ts b/src/processes/misc/enums.ts
index 35788187..429d8c41 100644
--- a/src/processes/misc/enums.ts
+++ b/src/processes/misc/enums.ts
@@ -9,7 +9,7 @@ export enum CommonProcess {
preClip = 'preClip',
clip = 'clip',
adjust = 'adjust',
- end = 'end',
+ end = 'end'
}
export enum AdapterProcess {
@@ -24,7 +24,7 @@ export enum AdapterProcess {
clip = 'adapter.clip',
insert = 'adapter.insert',
pause = 'adapter.pause',
- fix = 'adapter.fix',
+ fix = 'adapter.fix'
}
export enum ProcessStatus {
diff --git a/src/processes/postFetch.ts b/src/processes/postFetch.ts
index 52e99c44..c6805029 100644
--- a/src/processes/postFetch.ts
+++ b/src/processes/postFetch.ts
@@ -3,51 +3,51 @@ import { Scroller } from '../scroller';
import { Item } from '../classes/item';
export default class PostFetch extends BaseProcessFactory(CommonProcess.postFetch) {
-
static run(scroller: Scroller): void {
const { workflow } = scroller;
if (PostFetch.setItems(scroller)) {
PostFetch.setBufferLimits(scroller);
workflow.call({
process: PostFetch.process,
- status: scroller.state.fetch.hasNewItems
- ? ProcessStatus.next
- : ProcessStatus.done
+ status: scroller.state.fetch.hasNewItems ? ProcessStatus.next : ProcessStatus.done
});
} else {
workflow.call({
process: PostFetch.process,
status: ProcessStatus.error,
- payload: { error: 'Can\'t set buffer items' }
+ payload: { error: 'Can not set buffer items' }
});
}
}
static setBufferLimits(scroller: Scroller): void {
- const { buffer, state: { fetch, cycle: { innerLoop } } } = scroller;
- const { items, first: { index: first }, last: { index: last } } = fetch;
+ const { buffer, state } = scroller;
+ const { fetch, cycle } = state;
+ const { items, first, last } = fetch;
if (!items.length) {
- if (last < buffer.minIndex || innerLoop.isInitial) {
+ if (last.index < buffer.minIndex || cycle.innerLoop.isInitial) {
buffer.absMinIndex = buffer.minIndex;
}
- if (first > buffer.maxIndex || innerLoop.isInitial) {
+ if (first.index > buffer.maxIndex || cycle.innerLoop.isInitial) {
buffer.absMaxIndex = buffer.maxIndex;
}
} else {
const lastIndex = items.length - 1;
- if (first < items[0].$index) {
+ if (first.index < items[0].$index) {
buffer.absMinIndex = items[0].$index;
}
- if (last > items[lastIndex].$index) {
+ if (last.index > items[lastIndex].$index) {
buffer.absMaxIndex = items[lastIndex].$index;
}
}
}
static setItems(scroller: Scroller): boolean {
- const { buffer, state: { fetch, cycle } } = scroller;
+ const { buffer, state } = scroller;
+ const { fetch, cycle } = state;
const items = fetch.newItemsData;
- if (!items || !items.length) { // empty result
+ if (!items || !items.length) {
+ // empty result
return true;
}
// eof/bof case, need to shift fetch index if bof
@@ -61,10 +61,9 @@ export default class PostFetch extends BaseProcessFactory(CommonProcess.postFetc
fetchIndex = buffer.firstIndex - items.length;
}
}
- fetch.items = items.map((item, index: number) =>
- new Item(fetchIndex + index, item, scroller.routines)
+ fetch.items = items.map(
+ (item, index: number) => new Item(fetchIndex + index, item, scroller.routines)
);
return buffer.setItems(fetch.items);
}
-
}
diff --git a/src/processes/preClip.ts b/src/processes/preClip.ts
index 57e68d8e..f40c0cad 100644
--- a/src/processes/preClip.ts
+++ b/src/processes/preClip.ts
@@ -3,7 +3,6 @@ import { Scroller } from '../scroller';
import { Direction } from '../inputs/index';
export default class PreClip extends BaseProcessFactory(CommonProcess.preClip) {
-
static run(scroller: Scroller): void {
PreClip.prepareClip(scroller);
@@ -17,15 +16,17 @@ export default class PreClip extends BaseProcessFactory(CommonProcess.preClip) {
}
static prepareClip(scroller: Scroller): void {
- const { state: { fetch, clip } } = scroller;
+ const { fetch, clip } = scroller.state;
if (PreClip.shouldNotClip(scroller)) {
return;
}
const firstIndex = fetch.first.indexBuffer;
const lastIndex = fetch.last.indexBuffer;
- scroller.logger.log(() =>
- `looking for ${fetch.direction ? 'anti-' + fetch.direction + ' ' : ''}items ` +
- `that are out of [${firstIndex}..${lastIndex}] range`);
+ scroller.logger.log(
+ () =>
+ `looking for ${fetch.direction ? 'anti-' + fetch.direction + ' ' : ''}items ` +
+ `that are out of [${firstIndex}..${lastIndex}] range`
+ );
if (PreClip.isBackward(scroller, firstIndex)) {
PreClip.prepareClipByDirection(scroller, Direction.backward, firstIndex);
}
@@ -56,7 +57,8 @@ export default class PreClip extends BaseProcessFactory(CommonProcess.preClip) {
}
static isBackward(scroller: Scroller, firstIndex: number): boolean {
- const { buffer, state: { clip, fetch } } = scroller;
+ const { buffer, state } = scroller;
+ const { clip, fetch } = state;
if (clip.force) {
return clip.forceBackward;
}
@@ -69,7 +71,8 @@ export default class PreClip extends BaseProcessFactory(CommonProcess.preClip) {
}
static isForward(scroller: Scroller, lastIndex: number): boolean {
- const { buffer, state: { clip, fetch } } = scroller;
+ const { buffer, state } = scroller;
+ const { clip, fetch } = state;
if (clip.force) {
return clip.forceForward;
}
@@ -84,15 +87,11 @@ export default class PreClip extends BaseProcessFactory(CommonProcess.preClip) {
static prepareClipByDirection(scroller: Scroller, direction: Direction, edgeIndex: number): void {
const forward = direction === Direction.forward;
scroller.buffer.items.forEach(item => {
- if (
- (!forward && item.$index < edgeIndex) ||
- (forward && item.$index > edgeIndex)
- ) {
+ if ((!forward && item.$index < edgeIndex) || (forward && item.$index > edgeIndex)) {
item.toRemove = true;
item.removeDirection = direction;
scroller.state.clip.doClip = true;
}
});
}
-
}
diff --git a/src/processes/preFetch.ts b/src/processes/preFetch.ts
index d791b7b7..446bab88 100644
--- a/src/processes/preFetch.ts
+++ b/src/processes/preFetch.ts
@@ -3,9 +3,9 @@ import { Scroller } from '../scroller';
import { Direction } from '../inputs/index';
export default class PreFetch extends BaseProcessFactory(CommonProcess.preFetch) {
-
static run(scroller: Scroller): void {
- const { workflow, buffer, state: { fetch, cycle } } = scroller;
+ const { workflow, buffer, state } = scroller;
+ const { fetch, cycle } = state;
fetch.minIndex = buffer.minIndex;
// set first and last indexes of items to fetch
@@ -40,7 +40,8 @@ export default class PreFetch extends BaseProcessFactory(CommonProcess.preFetch)
}
static setPositions(scroller: Scroller): void {
- const { state: { fetch: { positions } }, viewport } = scroller;
+ const { state, viewport } = scroller;
+ const { positions } = state.fetch;
const paddingDelta = viewport.getBufferPadding();
positions.before = viewport.scrollPosition;
positions.startDelta = PreFetch.getStartDelta(scroller);
@@ -49,8 +50,10 @@ export default class PreFetch extends BaseProcessFactory(CommonProcess.preFetch)
positions.end = positions.relative + viewport.getSize() + paddingDelta;
}
- static getStartDelta(scroller: Scroller): number { // calculate size before start index
- const { buffer, viewport: { offset } } = scroller;
+ static getStartDelta(scroller: Scroller): number {
+ // calculate size before start index
+ const { buffer, viewport } = scroller;
+ const { offset } = viewport;
let startDelta = 0;
if (offset) {
startDelta += offset;
@@ -62,14 +65,16 @@ export default class PreFetch extends BaseProcessFactory(CommonProcess.preFetch)
startDelta += buffer.getSizeByIndex(index);
}
scroller.logger.log(() => [
- `start delta is ${startDelta}`, ...(offset ? [` (+${offset} offset)`] : [])
+ `start delta is ${startDelta}`,
+ ...(offset ? [` (+${offset} offset)`] : [])
]);
return startDelta;
}
static setFirstIndex(scroller: Scroller): void {
const { state, buffer } = scroller;
- const { positions: { start }, first } = state.fetch;
+ const { positions, first } = state.fetch;
+ const { start } = positions;
let firstIndex = buffer.startIndex;
let firstIndexPosition = 0;
if (state.cycle.innerLoop.isInitial) {
@@ -79,10 +84,10 @@ export default class PreFetch extends BaseProcessFactory(CommonProcess.preFetch)
} else {
let position = firstIndexPosition;
let index = firstIndex;
- while (1) { // eslint-disable-line no-constant-condition
+ while (true) {
if (start >= 0) {
const size = buffer.getSizeByIndex(index);
- const diff = (position + size) - start;
+ const diff = position + size - start;
if (diff > 0) {
firstIndex = index;
firstIndexPosition = position;
@@ -114,8 +119,10 @@ export default class PreFetch extends BaseProcessFactory(CommonProcess.preFetch)
}
static setLastIndex(scroller: Scroller): void {
- const { state: { fetch, cycle }, buffer, settings } = scroller;
- const { firstVisible, positions: { relative, end }, first, last } = fetch;
+ const { state, buffer, settings } = scroller;
+ const { fetch, cycle } = state;
+ const { firstVisible, positions, first, last } = fetch;
+ const { relative, end } = positions;
let lastIndex;
if (!buffer.defaultSize) {
// just to fetch forward bufferSize items if neither averageItemSize nor itemSize are present
@@ -125,7 +132,7 @@ export default class PreFetch extends BaseProcessFactory(CommonProcess.preFetch)
let index = first.indexBuffer;
let position = first.position;
lastIndex = index;
- while (1) { // eslint-disable-line no-constant-condition
+ while (true) {
lastIndex = index;
const size = buffer.getSizeByIndex(index);
position += size;
@@ -180,7 +187,8 @@ export default class PreFetch extends BaseProcessFactory(CommonProcess.preFetch)
}
static checkBufferGaps(scroller: Scroller): void {
- const { buffer, state: { fetch } } = scroller;
+ const { buffer, state } = scroller;
+ const { fetch } = state;
if (!buffer.size) {
return;
}
@@ -200,7 +208,8 @@ export default class PreFetch extends BaseProcessFactory(CommonProcess.preFetch)
}
static checkFetchPackSize(scroller: Scroller): void {
- const { buffer, state: { fetch } } = scroller;
+ const { buffer, state } = scroller;
+ const { fetch } = state;
if (!fetch.shouldFetch) {
return;
}
@@ -210,7 +219,8 @@ export default class PreFetch extends BaseProcessFactory(CommonProcess.preFetch)
if (diff <= 0) {
return;
}
- if (!buffer.size || lastIndex > buffer.items[0].$index) { // forward
+ if (!buffer.size || lastIndex > buffer.items[0].$index) {
+ // forward
const newLastIndex = Math.min(lastIndex + diff, buffer.absMaxIndex);
if (newLastIndex > lastIndex) {
fetch.last.index = fetch.last.indexBuffer = newLastIndex;
@@ -228,11 +238,13 @@ export default class PreFetch extends BaseProcessFactory(CommonProcess.preFetch)
}
static setFetchDirection(scroller: Scroller): void {
- const { buffer, state: { fetch } } = scroller;
+ const { buffer, state } = scroller;
+ const { fetch } = state;
if (fetch.last.index) {
let direction = Direction.forward;
if (buffer.size) {
- direction = fetch.last.index < buffer.items[0].$index ? Direction.backward : Direction.forward;
+ direction =
+ fetch.last.index < buffer.items[0].$index ? Direction.backward : Direction.forward;
}
fetch.direction = direction;
scroller.logger.log(() => `fetch direction is "${direction}"`);
@@ -246,10 +258,11 @@ export default class PreFetch extends BaseProcessFactory(CommonProcess.preFetch)
return ProcessStatus.next;
}
if (fetch.shouldFetch) {
- scroller.logger.log(() => `going to fetch ${fetch.count} items started from index ${fetch.index}`);
+ scroller.logger.log(
+ () => `going to fetch ${fetch.count} items started from index ${fetch.index}`
+ );
return ProcessStatus.next;
}
return ProcessStatus.done;
}
-
}
diff --git a/src/processes/render.ts b/src/processes/render.ts
index 1ffa1a11..e17b5917 100644
--- a/src/processes/render.ts
+++ b/src/processes/render.ts
@@ -3,46 +3,48 @@ import { Scroller } from '../scroller';
import { Item } from '../classes/item';
export default class Render extends BaseProcessFactory(CommonProcess.render) {
-
static run(scroller: Scroller): void {
- const { workflow, state: { cycle, render, scroll, fetch }, viewport, routines } = scroller;
+ const { workflow, state, viewport, routines } = scroller;
+ const { cycle, render, scroll, fetch } = state;
scroller.logger.stat('before new items render');
if (scroll.positionBeforeAsync === null) {
scroll.positionBeforeAsync = viewport.scrollPosition;
}
- render.cancel = routines.render(() => {
- render.cancel = null;
- if (Render.doRender(scroller)) {
- workflow.call({
- process: Render.process,
- status: render.noSize ? ProcessStatus.done : ProcessStatus.next,
- payload: { process: cycle.initiator }
- });
- } else {
- workflow.call({
- process: Render.process,
- status: ProcessStatus.error,
- payload: { error: 'Can\'t associate item with element' }
- });
- }
- }, { items: fetch.items.map(i => i.get()) });
+ render.cancel = routines.render(
+ () => {
+ render.cancel = null;
+ if (Render.doRender(scroller)) {
+ workflow.call({
+ process: Render.process,
+ status: render.noSize ? ProcessStatus.done : ProcessStatus.next,
+ payload: { process: cycle.initiator }
+ });
+ } else {
+ workflow.call({
+ process: Render.process,
+ status: ProcessStatus.error,
+ payload: { error: 'Can not associate item with element' }
+ });
+ }
+ },
+ { items: fetch.items.map(i => i.get()) }
+ );
}
static doRender(scroller: Scroller): boolean {
- const { state: { fetch, render }, viewport, buffer, logger } = scroller;
+ const { state, viewport, buffer, logger } = scroller;
+ const { fetch, render } = state;
render.positionBefore = viewport.scrollPosition;
if (!fetch.isCheck) {
render.sizeBefore = viewport.getScrollableSize();
- if (!fetch.items.every(item =>
- Render.processElement(scroller, item)
- )) {
+ if (!fetch.items.every(item => Render.processElement(scroller, item))) {
return false;
}
}
buffer.checkDefaultSize();
render.sizeAfter = viewport.getScrollableSize();
logger.stat('after new items render');
- logger.log(() => render.noSize ? 'viewport size has not been changed' : void 0);
+ logger.log(() => (render.noSize ? 'viewport size has not been changed' : void 0));
return true;
}
@@ -58,5 +60,4 @@ export default class Render extends BaseProcessFactory(CommonProcess.render) {
buffer.cacheItem(item);
return true;
}
-
}
diff --git a/src/processes/scroll.ts b/src/processes/scroll.ts
index f0a9ad74..cb558f67 100644
--- a/src/processes/scroll.ts
+++ b/src/processes/scroll.ts
@@ -4,9 +4,7 @@ import { Direction } from '../inputs/index';
import { ScrollEventData, ScrollerWorkflow } from '../interfaces/index';
export default class Scroll extends BaseProcessFactory(CommonProcess.scroll) {
-
- // eslint-disable-next-line @typescript-eslint/no-unused-vars
- static run(scroller: Scroller, payload?: { event?: Event }): void {
+ static run(scroller: Scroller, _payload?: { event?: Event }): void {
const { workflow, viewport } = scroller;
const position = viewport.scrollPosition;
@@ -14,9 +12,7 @@ export default class Scroll extends BaseProcessFactory(CommonProcess.scroll) {
return;
}
- Scroll.onThrottle(scroller, position, () =>
- Scroll.onScroll(scroller, workflow)
- );
+ Scroll.onThrottle(scroller, position, () => Scroll.onScroll(scroller, workflow));
}
static onSynthetic(scroller: Scroller, position: number): boolean {
@@ -28,29 +24,35 @@ export default class Scroll extends BaseProcessFactory(CommonProcess.scroll) {
}
if (!scroll.syntheticFulfill || synthPos === position) {
scroller.logger.log(() => [
- 'skipping scroll', position, `[${scroll.syntheticFulfill ? '' : 'pre-'}synthetic]`
+ 'skipping scroll',
+ position,
+ `[${scroll.syntheticFulfill ? '' : 'pre-'}synthetic]`
]);
return true;
}
scroller.logger.log(() => [
- 'synthetic scroll has been fulfilled:', position, position < synthPos ? '<' : '>', synthPos
+ 'synthetic scroll has been fulfilled:',
+ position,
+ position < synthPos ? '<' : '>',
+ synthPos
]);
}
return false;
}
static onThrottle(scroller: Scroller, position: number, done: () => void): void {
- const { state: { scroll }, settings: { throttle }, logger } = scroller;
+ const { state, settings, logger } = scroller;
+ const { scroll } = state;
scroll.current = Scroll.getScrollEvent(position, scroll.previous);
const { direction, time } = scroll.current;
const timeDiff = scroll.previous ? time - scroll.previous.time : Infinity;
- const delta = throttle - timeDiff;
+ const delta = settings.throttle - timeDiff;
const shouldDelay = isFinite(delta) && delta > 0;
const alreadyDelayed = !!scroll.scrollTimer;
logger.log(() => [
direction === Direction.backward ? '\u2934' : '\u2935',
position,
- shouldDelay ? (timeDiff + 'ms') : '0ms',
+ shouldDelay ? timeDiff + 'ms' : '0ms',
shouldDelay ? (alreadyDelayed ? 'delayed' : `/ ${delta}ms delay`) : ''
]);
if (!shouldDelay) {
@@ -68,7 +70,7 @@ export default class Scroll extends BaseProcessFactory(CommonProcess.scroll) {
return [
curr.direction === Direction.backward ? '\u2934' : '\u2935',
curr.position,
- (curr.time - time) + 'ms',
+ curr.time - time + 'ms',
'triggered by timer set on',
position
];
@@ -93,12 +95,16 @@ export default class Scroll extends BaseProcessFactory(CommonProcess.scroll) {
}
static onScroll(scroller: Scroller, workflow: ScrollerWorkflow): void {
- const { state: { scroll, cycle } } = scroller;
+ const { scroll, cycle } = scroller.state;
scroll.previous = { ...(scroll.current as ScrollEventData) };
scroll.current = null;
if (cycle.busy.get()) {
- scroller.logger.log(() => ['skipping scroll', (scroll.previous as ScrollEventData).position, '[pending]']);
+ scroller.logger.log(() => [
+ 'skipping scroll',
+ (scroll.previous as ScrollEventData).position,
+ '[pending]'
+ ]);
return;
}
@@ -107,5 +113,4 @@ export default class Scroll extends BaseProcessFactory(CommonProcess.scroll) {
status: ProcessStatus.next
});
}
-
}
diff --git a/src/processes/start.ts b/src/processes/start.ts
index ed63d9a1..db3e54a0 100644
--- a/src/processes/start.ts
+++ b/src/processes/start.ts
@@ -2,7 +2,6 @@ import { BaseProcessFactory, CommonProcess, ProcessStatus } from './misc/index';
import { Scroller } from '../scroller';
export default class Start extends BaseProcessFactory(CommonProcess.start) {
-
static run(scroller: Scroller): void {
const payload = scroller.state.startInnerLoop();
@@ -12,5 +11,4 @@ export default class Start extends BaseProcessFactory(CommonProcess.start) {
payload
});
}
-
}
diff --git a/src/scroller.ts b/src/scroller.ts
index 40cb6f1b..be65a461 100644
--- a/src/scroller.ts
+++ b/src/scroller.ts
@@ -10,7 +10,12 @@ import { Reactive } from './classes/reactive';
import { validate, DATASOURCE } from './inputs/index';
import core from './version';
import {
- ScrollerWorkflow, IDatasource, IDatasourceConstructed, ScrollerParams, IPackages, ProcessSubject
+ ScrollerWorkflow,
+ IDatasource,
+ IDatasourceConstructed,
+ ScrollerParams,
+ IPackages,
+ ProcessSubject
} from './interfaces/index';
export const INVALID_DATASOURCE_PREFIX = 'Invalid datasource:';
@@ -30,9 +35,14 @@ export class Scroller {
public adapter: Adapter;
constructor({
- datasource, consumer, element, workflow, Routines: CustomRoutines, scroller
+ datasource,
+ consumer,
+ element,
+ workflow,
+ Routines: CustomRoutines,
+ scroller
}: ScrollerParams) {
- const { params: { get } } = validate(datasource, DATASOURCE);
+ const { get } = validate(datasource, DATASOURCE).params;
if (!get.isValid) {
throw new Error(`${INVALID_DATASOURCE_PREFIX} ${get.errors[0]}`);
}
@@ -44,17 +54,23 @@ export class Scroller {
// In general, custom Routines must extend the original Routines. If not, we provide implicit extending.
// This is undocumented feature. It should be removed in vscroll v2.
if (CustomRoutines && !(CustomRoutines.prototype instanceof Routines)) {
- class __Routines extends Routines { }
+ class __Routines extends Routines {}
Object.getOwnPropertyNames(CustomRoutines.prototype)
.filter(method => method !== 'constructor')
- .forEach(method =>
- (__Routines.prototype as unknown as Record)[method] = CustomRoutines?.prototype[method]
+ .forEach(
+ method =>
+ ((__Routines.prototype as unknown as Record)[method] =
+ CustomRoutines?.prototype[method])
);
CustomRoutines = __Routines;
}
this.workflow = workflow;
- this.settings = new Settings(datasource.settings, datasource.devSettings, ++instanceCount);
+ this.settings = new Settings(
+ datasource.settings,
+ datasource.devSettings,
+ ++instanceCount
+ );
this.logger = new Logger(this as Scroller, packageInfo, datasource.adapter);
this.routines = new (CustomRoutines || Routines)(element, this.settings);
this.state = new State(packageInfo, this.settings, scroller ? scroller.state : void 0);
@@ -66,7 +82,8 @@ export class Scroller {
}
initDatasource(datasource: IDatasource, scroller?: Scroller