string templating

template strings and output them to a file (use-case: sql queries, ML datasets)

npm i --save string-templating

• usage
• config
• helper functions
  • range
  • random
• examples
• typescript
  • strongly typed returners

usage

import strTempl from 'string-templating'
 
const output = strTempl({
    amount: 5,
    template: '${iterator.num}+${iterator.num}=${returners.sum}',
    iterators: {
        num: function*() {
            yield* [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        }
    },
    returners: {
        sum: iterVals => iterVals.num[0] + iterVals.num[1]
    },
    recycle: true
})
 
console.log(output) // [`1+2=3`, `3+4=7`, `5+6=11`, `7+8=15`, `9+10=19`]

config

interface IStringifiable {
    toString: () => string
}
 
type IteratorMap = {
    [key: string]: () => Iterator<IStringifiable>
}
 
type ReturnerMap = {
    [key: string]: (iteratorValues: unknown) => IStringifiable
}
 
interface ITemplatingOptions {
    amount: number
    template: string
    outFile?: fs.PathLike
    iterators: IteratorMap
    returners?: ReturnerMap
    recycle?: boolean
}

• amount: amount of strings to be generated
• template: the string to be templated. ${iterators.yourname} in the string will be replaced with values from your iterators; ${returners.yourname} in the string will be replaced with values from your returners
• outFile: if you wish for the output to be saved to a file, specify a file path. If your file will have a json extention it will be saved as a json array
• iterators: object with your iterators
• returners: object with your returners. A returner will get all generated values from iterators as an object. Values will be stored as an array (if recycling is ON) or plain value (if recycling is OFF)
• recycle: if true, new values will be generated for each replacement in the template (otherwise each template generation gets one value)

helper functions

General purpose helper functions typical for string templating

range

import { range } from 'string-templating'

export function range(to: number): Iterable<number>
export function range(from: number, to: number, step?: number): Iterable<number>

for (let i of range(10)) console.log(i)
/*
0
1
2
3
4
5
6
7
8
9
*/
for (let i of range(7, 11)) console.log(i)
/*
7
8
9
10
*/
for (let i of range(5, 13, 3)) console.log(i)
/*
5
8
11
*/

random

import { random } from 'string-templating'

export function random(to: number, decimal?: boolean): number
export function random(from: number, to: number, decimal?: boolean): number
export function random<T>(array: T[]): T

random(5) // integer in the range of [0, 5)
random(5, true) // decimal in the range of [0, 5)
 
random(-3, 4) // integer in the range of [-3, 4)
random(-3, 4, true) // decimal in the range of [-3, 4)
 
random([1, true, 'whoop']) // returns random element from the array

examples

cd examples -> npm i -> node <example_name>

operations

Generates train.txt and test.txt. The files contain calculations: {num1}{operand}{num2}={result}. A very simple example of a dataset generated for a basic machine learning problem.

typescipt

strongly typed returners

Returners get iterator values as an unknown. There is a helper type ExtractIteratorValues to help you strongly type the values:

import StrTempl, { ExtractIteratorValues, ITemplatingOptions } from 'string-templating'
 
const iterators = {
    num: function*() {
        yield* [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    }
}
 
const config: ITemplatingOptions = {
    amount: 5,
    template: '${iterators.num}+${iterators.num}=${returners.sum}',
    iterators,
    returners: {
        sum: (iterVals: ExtractIteratorValues<typeof iterators, true>) =>
            iterVals.num[0] + iterVals.num[1]
    },
    recycle: true
}
 
const result = StrTempl(config)

Pass in your iterators and whether you're recycling them.