/
index.js
147 lines (126 loc) · 3.74 KB
/
index.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
import path from 'path';
import postcss from 'postcss';
import yaml from 'yaml';
import { lilconfigSync } from 'lilconfig';
import isResolvable from 'is-resolvable';
const cssnano = 'cssnano';
/*
* preset can be one of four possibilities:
* preset = 'default'
* preset = ['default', {}]
* preset = function <- to be invoked
* preset = {plugins: []} <- already invoked function
*/
function resolvePreset(preset) {
let fn, options;
if (Array.isArray(preset)) {
fn = preset[0];
options = preset[1];
} else {
fn = preset;
options = {};
}
// For JS setups where we invoked the preset already
if (preset.plugins) {
return preset.plugins;
}
// Provide an alias for the default preset, as it is built-in.
if (fn === 'default') {
return require('cssnano-preset-default')(options).plugins;
}
// For non-JS setups; we'll need to invoke the preset ourselves.
if (typeof fn === 'function') {
return fn(options).plugins;
}
// Try loading a preset from node_modules
if (isResolvable(fn)) {
return require(fn)(options).plugins;
}
const sugar = `cssnano-preset-${fn}`;
// Try loading a preset from node_modules (sugar)
if (isResolvable(sugar)) {
return require(sugar)(options).plugins;
}
// If all else fails, we probably have a typo in the config somewhere
throw new Error(
`Cannot load preset "${fn}". Please check your configuration for errors and try again.`
);
}
/*
* cssnano will look for configuration firstly as options passed
* directly to it, and failing this it will use lilconfig to
* load an external file.
*/
function resolveConfig(options) {
if (options.preset) {
return resolvePreset(options.preset);
}
let searchPath = process.cwd();
let configPath = null;
if (options.configFile) {
searchPath = null;
configPath = path.resolve(process.cwd(), options.configFile);
}
const configExplorer = lilconfigSync(cssnano, {
searchPlaces: [
'package.json',
'.cssnanorc',
'.cssnanorc.json',
'.cssnanorc.yaml',
'.cssnanorc.yml',
'.cssnanorc.js',
'cssnano.config.js',
],
loaders: {
'.yaml': (filepath, content) => yaml.parse(content),
'.yml': (filepath, content) => yaml.parse(content),
},
});
const config = configPath
? configExplorer.load(configPath)
: configExplorer.search(searchPath);
if (config === null) {
return resolvePreset('default');
}
return resolvePreset(config.config.preset || config.config);
}
const cssnanoPlugin = (options = {}) => {
if (Array.isArray(options.plugins)) {
if (!options.preset || !options.preset.plugins) {
options.preset = { plugins: [] };
}
options.plugins.forEach((plugin) => {
if (Array.isArray(plugin)) {
const [pluginDef, opts = {}] = plugin;
if (typeof pluginDef === 'string' && isResolvable(pluginDef)) {
options.preset.plugins.push([require(pluginDef), opts]);
} else {
options.preset.plugins.push([pluginDef, opts]);
}
} else if (typeof plugin === 'string' && isResolvable(plugin)) {
options.preset.plugins.push([require(plugin), {}]);
} else {
options.preset.plugins.push([plugin, {}]);
}
});
}
const plugins = [];
const nanoPlugins = resolveConfig(options);
for (const nanoPlugin of nanoPlugins) {
if (Array.isArray(nanoPlugin)) {
const [processor, opts] = nanoPlugin;
if (
typeof opts === 'undefined' ||
(typeof opts === 'object' && !opts.exclude) ||
(typeof opts === 'boolean' && opts === true)
) {
plugins.push(processor(opts));
}
} else {
plugins.push(nanoPlugin);
}
}
return postcss(plugins);
};
cssnanoPlugin.postcss = true;
export default cssnanoPlugin;