@tangle/linear-append
A strategy for tracking a set over time, when it matters when a certain thing was added to a Set, and when it was removed
Example Usage
This is mainly used with @tangle/strategy
to compose higher order strategies, and @tangle/reduce
to use it, but here's an example of using it stand alone
const LinearAppend = require('@tangle/linear-append')
const linearAppend = LinearAppend()
const input = [
{ key: [111, '@mix'], value: 'what shall we have for dinner?' },
{ key: [115, '@mix'], value: 'Keen, I would like one without onion plz' }
{ key: [112, '@ben'], value: 'PIZZA!' },
}
const T = linearAppend.mapFromInput(input)
// => {
// '111@mix': 'what shall we have for dinner?',
// '115@mix': 'Keen, I would like one without onion plz'
// '112@ben': 'PIZZA!',
// }
The raw transformations look like this:
{
[key]: value
}
where
-
key
String - a unique key used to later determine ordering in linear output- NOTE the human input is provided as an Array so you can provide multiple inputs which helps for tie-breaking
-
value
String - the value to be appended
linearAppend.mapToOutput(T)
// => [
// 'what shall we have for dinner?',
// 'PIZZA!',
// 'Keen, I would like one without onion plz'
// ]
API
LinearAppend(opts) => linearAppend
Instantiates a strategy, linearAppend
.
opts
Object is an optional object where you can specify:
-
keyPattern
String (optional)- a JSON schema pattern string which is used to validate keys
- Note that the Array of values in the human input is concatenated into a String key, and this is what is validated
- e.g.
'^@\w+$'
would make only keys like@mixmix
valid - default:
'^.+$'
-
valueSchema
Object (optional)- a JSON schema object used for validating the values passed in.
- default:
{ type: 'string', required: true }
linearAppend.concat(A, B) => C
linearAppend.identity() => I
returns "identity transformation"
linearAppend.mapFromInput(input) => T
Takes a human friendly (descriptive) input
and
returns a transformation T
which satisfies the
change requested in `input.
Format of input:
[
{ key: OrderingKey, value: AppendValue },
{ key: OrderingKey, value: AppendValue },
...
]
where:
-
OrderingKey
is an Array which will be concatenated and compared to other values for ordering -
AppendValue
is some value you want to append. Can be anything that passes yourvalueSchema
linearAppend.mapToOutput(T) => t
Takes a transformation T
and returns an output state t
, which is more
"human readable"
Format of output t
:
[
AppendValue,
AppendValue,
...
]
### `linearAppend.isValid(T) => Boolean`
### `linearAppend.schema`
Access the JSON schema that `isValid` was built with.
### `linearAppend.isConflict() => False`
### `linearAppend.isValidMerge() => True`
### `linearAppend.merge(graph, mergeNode, field) => T`
where:
- `graph` is a `@tangle/graph` instance
- `mergeNode` is the proposed merge-node
- `field` *String* contains the the data fields `node.data[field]`