README
interpolate
Interpolate is used to perform simple interpolations and (as best possible) their reverse operations.
import { interpolate, unterpolate } from '@zuze/interpolate';
const template = '{year}-{month}-{day}';
const interpolated = '2019-10-01';
unterpolate(template, interpolated)
/*
{
year:'2019',
month:'10',
day:'01'
}
*/
interpolate(template, {
year: '2019',
month: '10',
day: '01'
});
// '2019-10-01'
Installation
Same as usual, npm:
npm install @zuze/interpolate
or yarn:
yarn add @zuze/interpolate
You can also use it directly in the browser by doing:
<script src="https://unpkg.com/@zuze/interpolate"></script>
<script>
// creates a global variable ZInterpolate
const { unterpolate, interpolate, get, set, parts } = ZInterpolate;
</script>
Usage
Interpolations are ubiquitous, from the first templating engines, to internationalization, etc.
Interpolations don't have to just work for creating strings, however. With the right tools, it can be used to create more complex data transformations, which is the purpose of interpolate
.
Deeply Nested Objects
In addition to simple string mapping (see the first unterpolate
example) interpolate
supports transformations to/from deeply nested objects:
import { unterpolate, interpolate } from '@zuze/interpolate';
const template = '{first.second}-{first.third}-something-{first.fifth[0]}';
const interpolated = '2019-10-something-01';
interpolate(template,interpolated)
/*
{
first: {
second:'2019',
third:'10',
fifth:['01']
}
}
*/
unterpolate(template,{
first: {
second:'2019',
third:'10',
fifth:['01','02','03','04'] // extraneous values will be ignored
}
});
// '2019-10-something-01'
NOTE: interpolate
also accepts a function:
import { unterpolate, interpolate } from '@zuze/interpolate';
const template = '{year}-{month}-{day}';
const first = {
year: '2019',
month: '09',
day: '01',
};
const second = {
year: '2020',
month: '10',
day: '15',
};
const replacer = replaceWhat => replaceWhat === 'year' ? second[replaceWhat] : first[replaceWhat];
interpolate(template,replacer); //2020-09-01
complex object/array mapping
We don't only interpolate
an object's values to a string, we can interpolate them into a complex structure:
interpolated value is an array
const template = ['{first}','{second.first}','{third}-something'];
const interpolated = [['an','array'],20,'somestring-something'];
unterpolate(template,interpolated);
/*
{
first: ['an','array'],
second: {
first:20
},
third: 'somestring'
}
*/
// and magically...
interpolate(template, {
first: {
first: 'a',
second: 'b',
},
second: {
first: [ 'an', 'array' ]
},
third: 'must be a string'
});
/*
[
{
first:'a',
second:'b'
},
['an','array'],
'must be a string-something'
]
*/
interpolated value is an object
const template = {
first: '{someKey}',
second: {
third: '{first.first.0}'
},
fourth: [
'key1', // no { }
'{key1}',
'{first.second}'
]
}
const interpolated = {
first: 'something',
second: {
third: ['joe']
},
fourth: [
'key1',
'tom',
'bill'
]
}
unterpolate(template,interpolated);
/*
{
someKey:'something',
first: {
first:['joe'],
second:'bill'
},
key1:'tom',
}
*/
in/unterpolating using a function
Truth be told, unterpolate
was created to be able to do transformations through configuration which, under the circumstances in which it was developed, generally meant "through strings".
For full flexibility, interpolate
does support using a function to perform interpolations
and their reverse operations.
The function receives the the value
being in/unterpolated and the options given to the unterpolate/interpolate
function with a key of how
whose value is either unterpolate
or interpolate
.
Note: If unterpolate
the return value from the function must be false-y or an object - anything else will throw an error.
import { interpolate, unterpolate } from '@zuze/interpolate';
const template = {
first: (val, opts) => opts.how === 'interpolate' ? { prop: val / 2 } : val['prop'] * 2
};
const value = {
first: 20,
};
const expected = {
prop: 10,
};
unterpolate(template,value); // { prop: 10 }
interpolate(template,expected); // { first: 20 }
regexp match
The default RegExp
that determines what is an interpolation is /\{(.+?)\}/g
- or anything enclosed in curly braces - i.e. {first}
.
An object is created out of the matched strings which is then unflattened to create non-trivial structures.
You can pass a different match
regexp, if it suits your purposes, to unterpolate
and interpolate
like so:
const template = '$year$-$month$-$day