Class HGrid<DictVal>

Constructs a new grid.

const grid = new HGrid({
  columns: [
    {
      name: 'name'
    },
    {
      name: 'height'
    }
  ],
  // rows
  rows: [
    new HDict({ name: HStr.make('Mall'),  height: HNum.make(200, 'm') }),
    new HDict({ name: HStr.make('House'), height: HNum.make(30, 'm') })
  ]
})

// The same grid can be specified without any rows. The columns will be dynamically
// generated based upon the row data...
const grid0 = new HGrid({
  rows: [
    new HDict({ name: HStr.make('Mall'),  height: HNum.make(200, 'm') }),
    new HDict({ name: HStr.make('House'), height: HNum.make(30, 'm') })
  ]
})

// The same grid can be created from a Hayson object.
// Again columns don't have to be specified unless precise order and meta data is required...
const grid1 = new HGrid({
  rows: [
    { name: 'Mall', height: { _kind: 'number', val: 200, unit: 'm' } },
    { name: 'House', height: { _kind: 'number', val: 30, unit: 'm' } },
  ]
})

// Pass in a haystack value to create a grid...
const grid3 = new HGrid(HNum.make(24)) // Creates a grid with one column called 'val' and one row.

// Pass in an array of dicts to create a grid...
const grid4 = new HGrid([
  new HDict({ name: HStr.make('Mall'),  height: HNum.make(200, 'm') }),
  new HDict({ name: HStr.make('House'), height: HNum.make(30, 'm') })
])

// Pass in an array of Hayson dicts to create a grid...
const grid5 = new HGrid([
  { name: 'Mall', height: { _kind: 'number', val: 200, unit: 'm' } },
  { name: 'House', height: { _kind: 'number', val: 30, unit: 'm' } },
])
Copy

Return the first row in the grid or undefined if it can't be found.

const dict = grid.first
if (dict) {
  // Do something
}
Copy

Return the last row in the grid or undefined if it can't be found.

const dict = grid.last
if (dict) {
  // Do something
}
Copy

// The number of rows in a grid.
console.log(grid.length)
Copy

The grid's meta data.

Sets the grid's version number.

Iterate over a grid using dicts for rows.

This enables a 'for ... of' loop to be used directly on an iterator.

Add a single or multiple rows using dicts.

This method can be called in different ways to add multiple rows at a time.

// Add a single dict.
grid.add(new HDict({ foo: HStr.make('bar') }))

// Add multiple dicts.
grid.add(new HDict({ foo: HStr.make('bar') }), new HDict({ foo: HStr.make('bar') }))

// Add multiple dicts using an array...
grid.add([new HDict({ foo: HStr.make('bar') }), new HDict({ foo: HStr.make('bar') })])

// Same but using Hayson...
grid.add({ foo: 'bar' }))
grid.add({ foo: 'bar' }), { foo: 'bar' })
grid.add([{ foo: 'bar' }), { foo: 'bar' }])
Copy

Add a column and return its new instance.

If the column is already available then update it.

grid.addColumn('Address', new HDict({ length: 30 }))
Copy

Return true if the filter matches at least one row.

const grid = HGrid.make({
  rows: [
    { name: 'Fred' },
    { name: 'Fred' },
    { name: 'Fred' },
  ]
})

if (grid.all('name == "Fred")) {
  // All rows in the grid have the name Fred.
}
Copy

Return true if the filter matches all the values in a particular column in the grid.

This filter runs on the data held in the particular column.

const grid = HGrid.make({
  rows: [
    { list: [ 'foo', 'foo', 'foo' ] },
    { list: [ 'foo', 'foo', 'foo' ] },
    { list: [ 'foo', 'foo', 'foo' ] },
  ]
})

if (grid.allBy('list', 'item == "foo"')) {
  // True if all the lists contain all foos.
}
Copy

Return true if the filter matches at least one row.

if (grid.any('site')) {
  // The grid has some sites.
}
Copy

Return true if the filter matches at least one cell in a particular column in the grid.

This filter runs on the data held in the particular column.

const grid = HGrid.make({
  rows: [
    { list: [ 'foo', 'boo', 'goo' ] },
    { list: [ 'foo', 'boo1', 'goo1' ] },
    { list: [ 'doo', 'boo1', 'goo1' ] },
  ]
})

if (grid.anyBy('list', 'item === "foo"')) {
  // One or more of the items in the list contains 'foo'
}
Copy

Return the sum of values for the specified column.

If there are no numbers then Number.NaN is returned.

const grid = HGrid.make({
  rows: [
    { id: 34, num: 1 },
    { id: 35, num: 2 },
    { id: 36, num: 3 },
  ]
})
// Return average of the num column (2).
const avg = grid.avgOf('num')
Copy

// Create a grid with no rows (still retains column and meta).
grid.clear()
Copy

Clear all the rows from the grid.

Compares two grids.

Grid equality check.

Filter the grid with the haystack filter and return a new grid with the results.

// Filter a grid with a haystack filter
const newGridWithFoo = grid.filter('foo')

// Filter a grid with a function callback
const newGridWithFooAgain = grid.filter((row: HDict): boolean => row.has('foo'))
Copy

Filters an individual column in a grid.

For example, if a particular column in a grid holds a list. The inner filter can be run against all of the list values held in that column.

The filter can be run against a list, dict or grid.

const grid = HGrid.make({
  rows: [
    { list: [ 'foo', 'boo', 'goo' ] },
    { list: [ 'foo', 'boo1', 'goo1' ] },
    { list: [ 'doo', 'boo1', 'goo1' ] },
  ]
})

// Returns a grid with only the first two rows.
const newGrid = grid.filterBy('list', 'item == "foo"')
Copy

Return the first row dict that matches the filter or undefined if nothing is found.

const dict = grid.find('site'))
Copy

Return a row or undefined if it can't find it via its row number.

// Get a dict at a given index or returned undefined if it can't be found.
const dict = grid.get(0)
if (dict) {
  // Do something
}
Copy

Returns a grid column via its name or index number. If it can't be found then return undefined.

// Get the column at the specified index or return undefined
const col = grid.getColumn('Address')
if (col) {
  // Do something
}

// Alternatively use the column index to get the column
const col1 = grid.getColumn(3)
if (col1) {
  // Do something
}
Copy

Return the column names (not display names).

Return an array of column information.

// Return an array of column objects.
const cols = grid.getColumns()
Copy

Returns the number of columns.

console.log('The table has this many columns: ' + grid.getColumnsLength())
Copy

const err = grid.getError()
if (err) {
  // Do something with the error.
}
Copy

Return all the rows of the grid.

const anArrayOfDicts = grid.getRows()
Copy

Does the grid have the specified column?

if (grid.hasColumn('Address)) {
  // The grid has a column called address.
}
Copy

Insert rows as dicts at the specified index.

// Insert a single dict.
grid.insert(1, new HDict({ foo: HStr.make('bar') }))

// Insert multiple dicts.
grid.insert(1, new HDict({ foo: HStr.make('bar') }), new HDict({ foo: HStr.make('bar') }))

// Insert multiple dicts using an array...
grid.insert(1, [new HDict({ foo: HStr.make('bar') }), new HDict({ foo: HStr.make('bar') })])

// Same but using Hayson...
grid.insert(1, { foo: 'bar' }))
grid.insert(1, { foo: 'bar' }), { foo: 'bar' })
grid.insert(1, [{ foo: 'bar' }), { foo: 'bar' }])
Copy

Dump the value to the local console output.

if (grid.isEmpty()) {
  // Grid is empty.
}
Copy

if (grid.isError()) {
  // Do something.
}
Copy

Compares the value's kind.

Limit the grid only to the specified columns.

This will return a new instance of a grid.

grid.filter('site').limitColumns(['id', 'dis']).inspect()
Copy

Return a haystack list for all the values in the specified column.

If the column can't be found then an empty list is returned.

const grid = HGrid.make({
  rows: [
    { name: 'Gareth', id: 1 },
    { name: 'Jason', id: 2 },
    { name: 'Radu', id: 3 },
  ]
})

// Returns an HList<HStr> of the names (Gareth, Jason and Radu).
const listOfNames = grid.listBy<HStr>('name')
Copy

A mapping function that maps from an array of dicts into something else.

// Map each row to a div using React...
grid.map((dict: HDict) => <div>{dict.toZinc()}</div>>)
Copy

Returns true if the haystack filter matches the value.

This is the same as the any method.

if (grid.matches('site')) {
  // The grid has some sites.
}
Copy

Return the maximum value in the specified column.

If there are no numbers then Number.MIN_SAFE_INTEGER is returned.

const grid = HGrid.make({
  rows: [
    { id: 34, num: 1 },
    { id: 35, num: 2 },
    { id: 36, num: 3 },
  ]
})
// Return the maximum value in the num column (3).
const max = grid.maxOf('num')
Copy

Return the minimum of value in the specified column.

If there are no numbers then Number.MAX_SAFE_INTEGER is returned.

const grid = HGrid.make({
  rows: [
    { id: 34, num: 1 },
    { id: 35, num: 2 },
    { id: 36, num: 3 },
  ]
})
// Return the maximum value in the num column (1).
const min = grid.minOf('num')
Copy

Selects a range from the grid.

The start and end can be used to specify a range...

// from [0, 1, 2, 3, 4, 5] to [1, 2, 3, 4]
grid.filter('site').range(1, 4).inspect()
Copy

//If only the first argument then a quantity can be used...

// select the first 4 rows - [0, 1, 2, 4]...
grid.filter('site').range(4).inspect()
Copy

Reduce the rows in a grid.

// Reduce the grid down to one row...
grid = HGrid.make({
  rows: [
    { a: 1, b: 2 },
    { a: 3, b: 4 },
  ],
})

grid.reduce((prev, cur): HGrid => {
  const dict = prev.get(0)

  if (dict) {
    dict.set('a', Number(cur.get<HNum>('a')?.value) + Number(dict.get<HNum>('a')?.value))
    dict.set('b', Number(cur.get<HNum>('b')?.value) + Number(dict.get<HNum>('b')?.value))
  }

  return prev
}, HGrid.make({ rows: [{ a: 0, b: 0 }] }))
Copy

Refreshes a grid's columns based upon the rows in the grid.

Remove the row from the grid via its index number of a haystack filter.

// Remove a row via its index
grid.remove(0)

// Remove multiple rows via a Haystack Filter
grid.remove('foo == "baa"')
Copy

Reorder the columns with the specified new order of names.

const grid = HGrid.make({
  columns: [
    { name: 'b' },
    { name: 'c' },
    { name: 'a' },
  ]
})

// Reorder the columns to be a, b and then c.
grid.reorderColumns([ 'a', 'b', 'c' ])
Copy

Reverses the order of all the rows in the grid.

// Sort the grid in descending order by foo
grid.sortBy('foo').reverse()
Copy

Set the values or dict for an individual row.

// Set a row in a grid.
grid.set(0, new HDict({ foo: HStr.make('foobar') }))

// Set a row via Hayson.
grid.set(0, { foo: 'foobar' })
Copy

Set the column at the specified index number.

// Set the column at the specified index with the new name and length.
grid.setColumn(3, 'Address', new HDict({ length: 30 }))
Copy

Sort the grid in ascending order via a column name. This also supports sorting via multiple column names.

Precedence is given to the first columns in the table.

// Sorts the grid in ascending order by 'foo'
grid.sortBy('foo')

// Sorts the grid in ascending order by 'foo' and then by 'boo'
grid.sortBy(['foo', 'boo'])
Copy

Return the sum of values for the specified column.

const grid = HGrid.make({
  rows: [
    { id: 34, num: 1 },
    { id: 35, num: 2 },
    { id: 36, num: 3 },
  ]
})
// Sum all the values in the num column (6)
const sum = grid.sumOf('num')
Copy

Encodes to an encoded zinc value that can be used in a haystack filter string.

A grid isn't supported in filter so throw an error.

Encodes to an encoding zinc value.

Provide a grid with unique values in the specified columns.

const grid = HGrid.make({
  rows: [
	   { id: 1, name: 'Jason' },
	   { id: 2, name: 'Gareth' },
	   { id: 3, name: 'Gareth' },
  ]
})

// Returns a new grid with rows 1 and 2.
const uniqueGrid = grid.unique('name')
Copy

Makes a new grid.