# postcss-rem-to-rem-multiplier [![NPM version](https://badge.fury.io/js/postcss-rem-to-rem-multiplier.svg)](http://badge.fury.io/js/postcss-rem-to-rem-multiplier)

A plugin for [PostCSS](https://github.com/postcss/postcss) that multiplies rem with a multiplier to ajust for diffrent root font-size.

## Install

```shell
$ npm install postcss-rem-to-rem-multiplier --save-dev
```

## Usage

Sometimes you need to include a css file that uses rems.  Great pracitice!  Unless you can't afford to change your body font-size just for some one css. 

This script converts every rem value to a ajusted rem value from the properties you choose using a multiplier of default 0.625.


### Input/Output

*With the default settings, only font related properties are targeted.*

```css
// input
h1 {
    margin: 0 0 20px;
    font-size: 2rem;
    line-height: 1.2;
    letter-spacing: 0.0625rem;
}

// output
h1 {
    margin: 0 0 20px;
    font-size: 1.25rem;
    line-height: 1.2;
    letter-spacing: 1px;
}
```

### Example

```js
var fs = require('fs');
var postcss = require('postcss');
var remToPx = require('postcss-rem-to-rem-multiplier');
var css = fs.readFileSync('main.css', 'utf8');
var options = {};
var processedCss = postcss(remToPx(options)).process(css).css;

fs.writeFile('main-px.css', processedCss, function (err) {
  if (err) {
    throw err;
  }
  console.log('Rem file written.');
});
```

### options

Type: `Object | Null`  
Default:
```js
{
    multiplier: 0.625,
    unitPrecision: 5,
    selectorBlackList: [],
    propList: ['font', 'font-size', 'line-height', 'letter-spacing'],
    mediaQuery: false,
    multiplierCssVarName: null
}
```

- `multiplier` (Number) The multiplier by which to change the rem values default: (10/16) = 0.625.
    - Calculate the multiplier e.g. the given css is written for font-size: 16px (default browser font size), your page uses 10px font size. 10/16 = 0.625 
- `unitPrecision` (Number) The decimal precision px units are allowed to use, floored (rounding down on half).
- `propList` (Array) The properties that can change from rem to px.
    - Values need to be exact matches.
    - Use wildcard `*` to enable all properties. Example: `['*']`
    - Use `*` at the start or end of a word. (`['*position*']` will match `background-position-y`)
    - Use `!` to not match a property. Example: `['*', '!letter-spacing']`
    - Combine the "not" prefix with the other prefixes. Example: `['*', '!font*']` 
- `selectorBlackList` (Array) The selectors to ignore and leave as rem.
    - If value is string, it checks to see if selector contains the string.
        - `['body']` will match `.body-class`
    - If value is regexp, it checks to see if the selector matches the regexp.
        - `[/^body$/]` will match `body` but not `.body`
- `mediaQuery` (Boolean) Allow rem to be converted in media queries.
- `minRemValue` (Number) Set the minimum rem value to replace.
- `multiplierCssVarName` (String | Null) replaces  *multiplier* with a css variable <multiplierCssVarName>, the comupting to ajusted rem value then happends runtime in the browser. 
    - syntax use for runtime computation `calc(<currentRemvalue> * var(<multiplierCssVarName>))`


### Use with gulp-postcss and autoprefixer

```js
var gulp = require('gulp');
var postcss = require('gulp-postcss');
var autoprefixer = require('autoprefixer');
var remToPx = require('postcss-rem-to-rem-multiplier');

gulp.task('css', function () {

    var processors = [
        autoprefixer({
            browsers: 'last 1 version'
        }),
        remToPx()
    ];

    return gulp.src(['build/css/**/*.css'])
        .pipe(postcss(processors))
        .pipe(gulp.dest('build/css'));
});
```

### A message about ignoring properties
Currently, the easiest way to have a single property ignored is to use a capital in the rem unit declaration.

```css
// `rem` is converted to `rem` with a multiplier
.convert {
    font-size: 1rem; // converted to 0.625rem
}

// `Rem` or `REM` is ignored by `postcss-rem-to-rem-multiplier` but still accepted by browsers
.ignore {
    border: 1Rem solid; // ignored
    border-width: 2REM; // ignored
}
```


### Post css use multiplierCssVarName 

```js
{
  plugins: [
    [
      'postcss-rem-to-rem-multiplier', // ajust the rem vlaues used in canopy for 10px root font size to 10 px root font size in monoliht
      {
        multiplierCssVarName: '--r2r-multi',
        propList: ['*']
      }
    ]
  ]
}
```

```css
// source
.convert {
    font-size: 1rem; // converted to calc(0.625rem
}
```

```css
// output
.convert {
    font-size: calc(1rem * var(--r2r-multi); // converted to calc(0.625rem
}
```

## Credits

This repository is mainly based on the work from https://github.com/jesstech/postcss-rem-to-pixel.
The change is that it does not convert from rem to px with a multiplier, but convert rem to rem with a multiplier