vscroll 1.5.3 → 1.5.5

package/dist/typings/classes/state/fetch.d.ts

@@ -1,62 +1,62 @@
-import { Item } from '../item';
-import { Direction } from '../../inputs/index';
-declare class Positions {
-  startDelta: number;
-  before: number;
-  relative: number;
-  start: number;
-  end: number;
-  constructor();
-  reset(): void;
-}
-declare class First {
-  index: number;
-  indexBuffer: number;
-  position: number;
-  constructor();
-  reset(): void;
-}
-declare class Last {
-  index: number;
-  indexBuffer: number;
-  constructor();
-  reset(): void;
-}
-declare class FirstVisible {
-  index: number;
-  delta: number;
-  constructor();
-  reset(): void;
-}
-export declare class FetchModel {
-  private readonly directionPriority;
-  private _newItemsData;
-  items: Item[];
-  positions: Positions;
-  first: First;
-  last: Last;
-  hasAnotherPack: boolean;
-  callCount: number;
-  minIndex: number;
-  firstVisible: FirstVisible;
-  direction: Direction | null;
-  cancel: (() => void) | null;
-  simulate: boolean;
-  isCheck: boolean;
-  doRemove: boolean;
-  constructor(directionPriority: Direction);
-  reset(): void;
-  get newItemsData(): unknown[] | null;
-  set newItemsData(items: unknown[] | null);
-  get shouldFetch(): boolean;
-  get hasNewItems(): boolean;
-  get index(): number;
-  get count(): number;
-  shouldCheckPreSizeExpectation(lastBufferedIndex: number): boolean;
-  startSimulate(items: Item[]): void;
-  stopSimulate(): void;
-  fill(items: Item[], start: number): void;
-  check(items: Item[]): void;
-  update(index: number, delta: number, items: Item[], itemsToRemove: Item[]): void;
-}
-export {};
+import { Item } from '../item';
+import { Direction } from '../../inputs/index';
+declare class Positions {
+  startDelta: number;
+  before: number;
+  relative: number;
+  start: number;
+  end: number;
+  constructor();
+  reset(): void;
+}
+declare class First {
+  index: number;
+  indexBuffer: number;
+  position: number;
+  constructor();
+  reset(): void;
+}
+declare class Last {
+  index: number;
+  indexBuffer: number;
+  constructor();
+  reset(): void;
+}
+declare class FirstVisible {
+  index: number;
+  delta: number;
+  constructor();
+  reset(): void;
+}
+export declare class FetchModel {
+  private readonly directionPriority;
+  private _newItemsData;
+  items: Item[];
+  positions: Positions;
+  first: First;
+  last: Last;
+  hasAnotherPack: boolean;
+  callCount: number;
+  minIndex: number;
+  firstVisible: FirstVisible;
+  direction: Direction | null;
+  cancel: (() => void) | null;
+  simulate: boolean;
+  isCheck: boolean;
+  doRemove: boolean;
+  constructor(directionPriority: Direction);
+  reset(): void;
+  get newItemsData(): unknown[] | null;
+  set newItemsData(items: unknown[] | null);
+  get shouldFetch(): boolean;
+  get hasNewItems(): boolean;
+  get index(): number;
+  get count(): number;
+  shouldCheckPreSizeExpectation(lastBufferedIndex: number): boolean;
+  startSimulate(items: Item[]): void;
+  stopSimulate(): void;
+  fill(items: Item[], start: number): void;
+  check(items: Item[]): void;
+  update(index: number, delta: number, items: Item[], itemsToRemove: Item[]): void;
+}
+export {};

package/dist/typings/classes/state/render.d.ts

@@ -1,9 +1,9 @@
-export declare class RenderModel {
-  sizeBefore: number;
-  sizeAfter: number;
-  positionBefore: number;
-  cancel: (() => void) | null;
-  get noSize(): boolean;
-  constructor();
-  reset(): void;
-}
+export declare class RenderModel {
+  sizeBefore: number;
+  sizeAfter: number;
+  positionBefore: number;
+  cancel: (() => void) | null;
+  get noSize(): boolean;
+  constructor();
+  reset(): void;
+}

package/dist/typings/classes/state/scroll.d.ts

@@ -1,16 +1,16 @@
-import { ScrollEventData as IScrollEventData } from '../../interfaces/index';
-export declare class ScrollModel {
-  previous: IScrollEventData | null;
-  current: IScrollEventData | null;
-  scrollTimer: ReturnType<typeof setTimeout> | null;
-  syntheticPosition: number | null;
-  syntheticFulfill: boolean;
-  cancelAnimation: (() => void) | null;
-  positionBeforeAsync: number | null;
-  positionBeforeAdjust: number | null;
-  positionAfterAdjust: number | null;
-  constructor();
-  reset(): void;
-  stop(): void;
-  hasPositionChanged(position: number): boolean;
-}
+import { ScrollEventData as IScrollEventData } from '../../interfaces/index';
+export declare class ScrollModel {
+  previous: IScrollEventData | null;
+  current: IScrollEventData | null;
+  scrollTimer: ReturnType<typeof setTimeout> | null;
+  syntheticPosition: number | null;
+  syntheticFulfill: boolean;
+  cancelAnimation: (() => void) | null;
+  positionBeforeAsync: number | null;
+  positionBeforeAdjust: number | null;
+  positionAfterAdjust: number | null;
+  constructor();
+  reset(): void;
+  stop(): void;
+  hasPositionChanged(position: number): boolean;
+}

package/dist/typings/classes/state.d.ts

@@ -1,27 +1,27 @@
-import { Settings } from './settings';
-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 declare class State implements IState {
-  readonly packageInfo: IPackages;
-  private settings;
-  initTime: number;
-  cycle: WorkflowCycleModel;
-  fetch: FetchModel;
-  clip: ClipModel;
-  render: RenderModel;
-  scroll: ScrollModel;
-  get time(): number;
-  constructor(packageInfo: IPackages, settings: Settings, state?: IState);
-  startWorkflowCycle(isInitial: boolean, initiator: ProcessName): void;
-  endWorkflowCycle(count: number): void;
-  startInnerLoop(): {
-    process?: ProcessName;
-    doRender?: boolean;
-  };
-  endInnerLoop(): void;
-  dispose(): void;
-}
+import { Settings } from './settings';
+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 declare class State implements IState {
+  readonly packageInfo: IPackages;
+  private settings;
+  initTime: number;
+  cycle: WorkflowCycleModel;
+  fetch: FetchModel;
+  clip: ClipModel;
+  render: RenderModel;
+  scroll: ScrollModel;
+  get time(): number;
+  constructor(packageInfo: IPackages, settings: Settings, state?: IState);
+  startWorkflowCycle(isInitial: boolean, initiator: ProcessName): void;
+  endWorkflowCycle(count: number): void;
+  startInnerLoop(): {
+    process?: ProcessName;
+    doRender?: boolean;
+  };
+  endInnerLoop(): void;
+  dispose(): void;
+}

package/dist/typings/classes/viewport.d.ts

@@ -1,32 +1,32 @@
-import { Paddings } from './paddings';
-import { Settings } from './settings';
-import { Routines } from './domRoutines';
-import { Item } from './item';
-import { State } from './state';
-import { Logger } from './logger';
-import { Direction } from '../inputs/index';
-export declare class Viewport {
-  offset: number;
-  paddings: Paddings;
-  readonly settings: Settings;
-  readonly routines: Routines;
-  readonly state: State;
-  readonly logger: Logger;
-  constructor(settings: Settings, routines: Routines, state: State, logger: Logger);
-  reset(startIndex: number): void;
-  setPosition(value: number): number;
-  get scrollPosition(): number;
-  set scrollPosition(value: number);
-  getSize(): number;
-  getScrollableSize(): number;
-  getMaxScrollPosition(): number;
-  getBufferPadding(): number;
-  getEdge(direction: Direction): number;
-  setOffset(): void;
-  findItemElementById(id: string): HTMLElement | null;
-  getEdgeVisibleItem(items: Item[], direction: Direction): {
-    item?: Item;
-    index: number;
-    diff: number;
-  };
-}
+import { Paddings } from './paddings';
+import { Settings } from './settings';
+import { Routines } from './domRoutines';
+import { Item } from './item';
+import { State } from './state';
+import { Logger } from './logger';
+import { Direction } from '../inputs/index';
+export declare class Viewport {
+  offset: number;
+  paddings: Paddings;
+  readonly settings: Settings;
+  readonly routines: Routines;
+  readonly state: State;
+  readonly logger: Logger;
+  constructor(settings: Settings, routines: Routines, state: State, logger: Logger);
+  reset(startIndex: number): void;
+  setPosition(value: number): number;
+  get scrollPosition(): number;
+  set scrollPosition(value: number);
+  getSize(): number;
+  getScrollableSize(): number;
+  getMaxScrollPosition(): number;
+  getBufferPadding(): number;
+  getEdge(direction: Direction): number;
+  setOffset(): void;
+  findItemElementById(id: string): HTMLElement | null;
+  getEdgeVisibleItem(items: Item[], direction: Direction): {
+    item?: Item;
+    index: number;
+    diff: number;
+  };
+}

package/dist/typings/index.d.ts

@@ -1,9 +1,9 @@
-import { Workflow } from './workflow';
-import { makeDatasource } from './classes/datasource';
-import packageInfo from './version';
-import { INVALID_DATASOURCE_PREFIX } from './scroller';
-import { AdapterPropName, EMPTY_ITEM, getDefaultAdapterProps } from './classes/adapter/props';
-import { Direction, SizeStrategy } from './inputs/index';
-import { IDatasource, IDatasourceConstructed, IRoutines, IReactivePropConfig, IAdapterConfig, ItemAdapter, IAdapter, Item } from './interfaces/index';
-export { Workflow, makeDatasource, packageInfo, INVALID_DATASOURCE_PREFIX, AdapterPropName, EMPTY_ITEM, getDefaultAdapterProps, Direction, SizeStrategy, };
-export { IDatasource, IDatasourceConstructed, IRoutines, IReactivePropConfig, IAdapterConfig, ItemAdapter as IAdapterItem, IAdapter, Item, };
+import { Workflow } from './workflow';
+import { makeDatasource } from './classes/datasource';
+import packageInfo from './version';
+import { INVALID_DATASOURCE_PREFIX } from './scroller';
+import { AdapterPropName, EMPTY_ITEM, getDefaultAdapterProps } from './classes/adapter/props';
+import { Direction, SizeStrategy } from './inputs/index';
+import { IDatasource, IDatasourceConstructed, IRoutines, IReactivePropConfig, IAdapterConfig, ItemAdapter, IAdapter, Item } from './interfaces/index';
+export { Workflow, makeDatasource, packageInfo, INVALID_DATASOURCE_PREFIX, AdapterPropName, EMPTY_ITEM, getDefaultAdapterProps, Direction, SizeStrategy, };
+export { IDatasource, IDatasourceConstructed, IRoutines, IReactivePropConfig, IAdapterConfig, ItemAdapter as IAdapterItem, IAdapter, Item, };

package/dist/typings/inputs/adapter.d.ts

@@ -1,5 +1,5 @@
-import { ICommonProps, AdapterProcessMap } from '../interfaces/index';
-export declare const AdapterMethods: AdapterProcessMap<{
-  [key: string]: string;
-}>;
-export declare const ADAPTER_METHODS: AdapterProcessMap<ICommonProps<PropertyKey>>;
+import { ICommonProps, AdapterProcessMap } from '../interfaces/index';
+export declare const AdapterMethods: AdapterProcessMap<{
+  [key: string]: string;
+}>;
+export declare const ADAPTER_METHODS: AdapterProcessMap<ICommonProps<PropertyKey>>;

package/dist/typings/inputs/common.d.ts

@@ -1,9 +1,9 @@
-export declare enum Direction {
-  forward = "forward",
-  backward = "backward"
-}
-export declare enum SizeStrategy {
-  Average = "average",
-  Constant = "constant",
-  Frequent = "frequent"
-}
+export declare enum Direction {
+  forward = "forward",
+  backward = "backward"
+}
+export declare enum SizeStrategy {
+  Average = "average",
+  Constant = "constant",
+  Frequent = "frequent"
+}

package/dist/typings/inputs/datasource.d.ts

@@ -1,7 +1,7 @@
-import { ICommonProps } from '../interfaces/index';
-export declare enum DatasourceProps {
-  get = "get",
-  settings = "settings",
-  devSettings = "devSettings"
-}
-export declare const DATASOURCE: ICommonProps<DatasourceProps>;
+import { ICommonProps } from '../interfaces/index';
+export declare enum DatasourceProps {
+  get = "get",
+  settings = "settings",
+  devSettings = "devSettings"
+}
+export declare const DATASOURCE: ICommonProps<DatasourceProps>;

package/dist/typings/inputs/index.d.ts

@@ -1,6 +1,6 @@
-import { Direction, SizeStrategy } from './common';
-import { ValidatorType, VALIDATORS, validateOne, validate } from './validation';
-import { DatasourceProps, DATASOURCE } from './datasource';
-import { SETTINGS, DEV_SETTINGS } from './settings';
-import { AdapterMethods, ADAPTER_METHODS } from './adapter';
-export { Direction, SizeStrategy, ValidatorType, VALIDATORS, validateOne, validate, DatasourceProps, DATASOURCE, SETTINGS, DEV_SETTINGS, AdapterMethods, ADAPTER_METHODS, };
+import { Direction, SizeStrategy } from './common';
+import { ValidatorType, VALIDATORS, validateOne, validate } from './validation';
+import { DatasourceProps, DATASOURCE } from './datasource';
+import { SETTINGS, DEV_SETTINGS } from './settings';
+import { AdapterMethods, ADAPTER_METHODS } from './adapter';
+export { Direction, SizeStrategy, ValidatorType, VALIDATORS, validateOne, validate, DatasourceProps, DATASOURCE, SETTINGS, DEV_SETTINGS, AdapterMethods, ADAPTER_METHODS, };

package/dist/typings/inputs/settings.d.ts

@@ -1,41 +1,41 @@
-import { ICommonProps } from '../interfaces/index';
-declare enum Settings {
-  adapter = "adapter",
-  startIndex = "startIndex",
-  minIndex = "minIndex",
-  maxIndex = "maxIndex",
-  itemSize = "itemSize",
-  bufferSize = "bufferSize",
-  padding = "padding",
-  infinite = "infinite",
-  horizontal = "horizontal",
-  windowViewport = "windowViewport",
-  viewportElement = "viewportElement",
-  inverse = "inverse",
-  onBeforeClip = "onBeforeClip",
-  sizeStrategy = "sizeStrategy"
-}
-declare enum DevSettings {
-  debug = "debug",
-  immediateLog = "immediateLog",
-  logProcessRun = "logProcessRun",
-  logTime = "logTime",
-  throttle = "throttle",
-  initDelay = "initDelay",
-  initWindowDelay = "initWindowDelay",
-  cacheData = "cacheData",
-  cacheOnReload = "cacheOnReload",
-  dismissOverflowAnchor = "dismissOverflowAnchor",
-  directionPriority = "directionPriority"
-}
-export declare const MIN: {
-  itemSize: number;
-  bufferSize: number;
-  padding: number;
-  throttle: number;
-  initDelay: number;
-  initWindowDelay: number;
-};
-export declare const SETTINGS: ICommonProps<Settings>;
-export declare const DEV_SETTINGS: ICommonProps<DevSettings>;
-export {};
+import { ICommonProps } from '../interfaces/index';
+declare enum Settings {
+  adapter = "adapter",
+  startIndex = "startIndex",
+  minIndex = "minIndex",
+  maxIndex = "maxIndex",
+  itemSize = "itemSize",
+  bufferSize = "bufferSize",
+  padding = "padding",
+  infinite = "infinite",
+  horizontal = "horizontal",
+  windowViewport = "windowViewport",
+  viewportElement = "viewportElement",
+  inverse = "inverse",
+  onBeforeClip = "onBeforeClip",
+  sizeStrategy = "sizeStrategy"
+}
+declare enum DevSettings {
+  debug = "debug",
+  immediateLog = "immediateLog",
+  logProcessRun = "logProcessRun",
+  logTime = "logTime",
+  throttle = "throttle",
+  initDelay = "initDelay",
+  initWindowDelay = "initWindowDelay",
+  cacheData = "cacheData",
+  cacheOnReload = "cacheOnReload",
+  dismissOverflowAnchor = "dismissOverflowAnchor",
+  directionPriority = "directionPriority"
+}
+export declare const MIN: {
+  itemSize: number;
+  bufferSize: number;
+  padding: number;
+  throttle: number;
+  initDelay: number;
+  initWindowDelay: number;
+};
+export declare const SETTINGS: ICommonProps<Settings>;
+export declare const DEV_SETTINGS: ICommonProps<DevSettings>;
+export {};

package/dist/typings/inputs/validation.d.ts

@@ -1,83 +1,83 @@
-import { IValidationContext } from '../interfaces/validation';
-import { IValidator, ValidatedValue, IValidatedData, IValidatedCommonProps, ICommonProps, ICommonProp } from '../interfaces/index';
-export declare enum ValidatorType {
-  number = "must be a number",
-  integer = "must be an integer",
-  integerUnlimited = "must be an integer or infinity",
-  moreOrEqual = "must be a number greater than (or equal to) {arg1}",
-  itemList = "must be an array of items {arg1}",
-  boolean = "must be a boolean",
-  object = "must be an object",
-  element = "must be an html element",
-  function = "must be a function",
-  funcOfxArguments = "must have {arg1} argument(s)",
-  funcOfxAndMoreArguments = "must have at least {arg1} argument(s)",
-  funcOfXToYArguments = "must have {arg1} to {arg2} arguments",
-  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"
-}
-declare enum AbstractEnum {
-}
-declare type TEnum = typeof AbstractEnum;
-export declare const VALIDATORS: {
-  NUMBER: {
-    type: ValidatorType;
-    method: (value: unknown) => ValidatedValue;
-  };
-  INTEGER: {
-    type: ValidatorType;
-    method: (value: unknown) => ValidatedValue;
-  };
-  INTEGER_UNLIMITED: {
-    type: ValidatorType;
-    method: (value: unknown) => ValidatedValue;
-  };
-  MORE_OR_EQUAL: (limit: number, fallback?: boolean | undefined) => IValidator;
-  BOOLEAN: {
-    type: ValidatorType;
-    method: (value: unknown) => ValidatedValue;
-  };
-  OBJECT: {
-    type: ValidatorType;
-    method: (value: unknown) => ValidatedValue;
-  };
-  ITEM_LIST: {
-    type: ValidatorType;
-    method: (value: unknown) => ValidatedValue;
-  };
-  ELEMENT: {
-    type: ValidatorType;
-    method: (value: unknown) => ValidatedValue;
-  };
-  FUNC: {
-    type: ValidatorType;
-    method: (value: unknown) => ValidatedValue;
-  };
-  FUNC_WITH_X_ARGUMENTS: (count: number) => IValidator;
-  FUNC_WITH_X_AND_MORE_ARGUMENTS: (count: number) => IValidator;
-  FUNC_WITH_X_TO_Y_ARGUMENTS: (from: number, to: number) => IValidator;
-  ONE_OF_CAN: (list: string[]) => IValidator;
-  ONE_OF_MUST: (list: string[]) => IValidator;
-  OR: (list: IValidator[]) => IValidator;
-  ENUM: (list: TEnum) => IValidator;
-};
-export declare class ValidatedData implements IValidatedData {
-  context: IValidationContext;
-  isValidContext: boolean;
-  isValid: boolean;
-  errors: string[];
-  params: IValidatedCommonProps<PropertyKey>;
-  private contextErrors;
-  constructor(context: unknown);
-  private setContext;
-  private setValidity;
-  setCommonError(error: string): void;
-  setParam(token: string, value: ValidatedValue): void;
-  showErrors(): string;
-}
-export declare const runValidator: (current: ValidatedValue, validator: IValidator, context: IValidationContext) => ValidatedValue;
-export declare const validateOne: (context: IValidationContext, name: string, prop: ICommonProp) => ValidatedValue;
-export declare const validate: (context: unknown, params: ICommonProps<PropertyKey>) => IValidatedData;
-export {};
+import { IValidationContext } from '../interfaces/validation';
+import { IValidator, ValidatedValue, IValidatedData, IValidatedCommonProps, ICommonProps, ICommonProp } from '../interfaces/index';
+export declare enum ValidatorType {
+  number = "must be a number",
+  integer = "must be an integer",
+  integerUnlimited = "must be an integer or infinity",
+  moreOrEqual = "must be a number greater than (or equal to) {arg1}",
+  itemList = "must be an array of items {arg1}",
+  boolean = "must be a boolean",
+  object = "must be an object",
+  element = "must be an html element",
+  function = "must be a function",
+  funcOfxArguments = "must have {arg1} argument(s)",
+  funcOfxAndMoreArguments = "must have at least {arg1} argument(s)",
+  funcOfXToYArguments = "must have {arg1} to {arg2} arguments",
+  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"
+}
+declare enum AbstractEnum {
+}
+declare type TEnum = typeof AbstractEnum;
+export declare const VALIDATORS: {
+  NUMBER: {
+    type: ValidatorType;
+    method: (value: unknown) => ValidatedValue;
+  };
+  INTEGER: {
+    type: ValidatorType;
+    method: (value: unknown) => ValidatedValue;
+  };
+  INTEGER_UNLIMITED: {
+    type: ValidatorType;
+    method: (value: unknown) => ValidatedValue;
+  };
+  MORE_OR_EQUAL: (limit: number, fallback?: boolean | undefined) => IValidator;
+  BOOLEAN: {
+    type: ValidatorType;
+    method: (value: unknown) => ValidatedValue;
+  };
+  OBJECT: {
+    type: ValidatorType;
+    method: (value: unknown) => ValidatedValue;
+  };
+  ITEM_LIST: {
+    type: ValidatorType;
+    method: (value: unknown) => ValidatedValue;
+  };
+  ELEMENT: {
+    type: ValidatorType;
+    method: (value: unknown) => ValidatedValue;
+  };
+  FUNC: {
+    type: ValidatorType;
+    method: (value: unknown) => ValidatedValue;
+  };
+  FUNC_WITH_X_ARGUMENTS: (count: number) => IValidator;
+  FUNC_WITH_X_AND_MORE_ARGUMENTS: (count: number) => IValidator;
+  FUNC_WITH_X_TO_Y_ARGUMENTS: (from: number, to: number) => IValidator;
+  ONE_OF_CAN: (list: string[]) => IValidator;
+  ONE_OF_MUST: (list: string[]) => IValidator;
+  OR: (list: IValidator[]) => IValidator;
+  ENUM: (list: TEnum) => IValidator;
+};
+export declare class ValidatedData implements IValidatedData {
+  context: IValidationContext;
+  isValidContext: boolean;
+  isValid: boolean;
+  errors: string[];
+  params: IValidatedCommonProps<PropertyKey>;
+  private contextErrors;
+  constructor(context: unknown);
+  private setContext;
+  private setValidity;
+  setCommonError(error: string): void;
+  setParam(token: string, value: ValidatedValue): void;
+  showErrors(): string;
+}
+export declare const runValidator: (current: ValidatedValue, validator: IValidator, context: IValidationContext) => ValidatedValue;
+export declare const validateOne: (context: IValidationContext, name: string, prop: ICommonProp) => ValidatedValue;
+export declare const validate: (context: unknown, params: ICommonProps<PropertyKey>) => IValidatedData;
+export {};