Working with Data

When working with data, you will mostly interact with the <DataSource /> component, which is responsible for handling and managing the data and passing it down to the <InfiniteTable /> component, which is the rendering engine for the DataGrid.
So we provide those two components (as named exports) inside @infinite-table/infinite-vue package:
  • <DataSource /> - our data-handling component
  • <InfiniteTable /> - our virtualized component
The <DataSource/> component is responsible for the data the management layer.
Probably the most important prop for the <DataSource /> component is the primaryKey prop. It specifies the property of the data object that is used as a unique identifier for data rows/items.
<!-- `data` can also be a Promise or a function returning a Promise -->
<DataSource primaryKey="id" :data="[]" />
The <DataSource /> component is bound to an array of items. In a Vue template the component takes no type parameter - when using TypeScript, the types of the props are generic, so you type the values you bind with them: DataSourceData<DATA_TYPE> for the data prop, InfiniteTablePropColumns<DATA_TYPE> for the columns.
In this documentation, we'll use DATA_TYPE when referring to the generic type. Rarely, we'll use T.
import type {
  DataSourceData,
  InfiniteTablePropColumns,
} from '@infinite-table/infinite-vue';

const data: DataSourceData<DATA_TYPE> = [ /* ... */ ];
const columns: InfiniteTablePropColumns<DATA_TYPE> = { /* ... */ };

// <DataSource primaryKey="id" :data="data">
//   <InfiniteTable :columns="columns" />
// </DataSource>
Most of our examples in these docs have a Developer or Employee TypeScript data type used as the generic type.
import { DataSource } from '@infinite-table/infinite-vue';

type Employee = {
  id: string | number;
  name: string;
  salary: number;
  department: string;
  company: string;
};

const employees: Employee[] = [
  { id: 1, name: 'Bob', salary: 10_000, department: 'IT', company: 'Bobsons' },
  {
    id: 2,
    name: 'Alice',
    salary: 20_000,
    department: 'IT',
    company: 'Bobsons',
  },
  { id: 3, name: 'John', salary: 30_000, department: 'IT', company: 'Bobsons' },
];

// <DataSource primaryKey="id" :data="employees" />
In the snippet above, we see 3 important details:
  1. the employees array is typed as Employee[]
  2. we use a primaryKey property - here it is id, which is a property of the Employee type
  3. we pass the employees array as the data property, bound with :data.
The data prop can be either:
  • an array of the bound generic type - here Employee[]
  • a Promise tha resolves to an array like the above
  • a function that returns any of the above
#
Data loading example with promise
open
loading demo…

Data Loading Strategies#

We're aware there are countless strategies for loading data - each with its own strengths. We decided we should focus on building what we do best, namely building virtualized components, so we encourage you to use your preferred data-fetching library/solution. This being said, we still provide you with the flexibility you need when using the <DataSource/>, so here's what you can use for the data prop of the component:
  • an array of the bound type
  • a Promise that resolves to an array of the bound type
  • a function that returns any of the above
While you're loading the data, you can always render a loading indicator - pass the loading prop into the component (along with loadingText prop in the <InfiniteTable /> component if you want to customize the message).

Using fetch#

For basic datasets, which have simple data requirements, using fetch is probably sufficient, so here is an example:
#
Using fetch for remote data
open
loading demo…

Re-fetching on change

It's important to note you can re-fetch data by changing the reference you pass as the data prop to the <DataSource/> component.
Passing another data function, will cause the component to re-execute the function and thus load new data.
Alternatively, you can use the refetchKey prop to trigger a re-fetch - give it a new value (eg: use it as a counter, and increment it) and the component will re-fetch the data.
#
Re-fetching data
open
loading demo…

Live Updates#

You can update your data in real-time by using our DataSource API.

DataSource API

Read more about how to use our API to update your data in real-time