/
index.ts
275 lines (259 loc) · 6.35 KB
/
index.ts
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
import * as postcss from "postcss";
/**
* @public
*/
export type PostCSSRoot = postcss.Root;
/**
* @internal
*/
export interface AtRules {
fontFace: Array<{
name: string;
node: postcss.AtRule;
}>;
keyframes: postcss.AtRule[];
}
/**
* @public
*/
export interface RawContent<T = string> {
extension: string;
raw: T;
}
/**
* @public
*/
export interface RawCSS {
raw: string;
name?: string;
}
/**
* @public
*/
export interface ExtractorResultDetailed {
attributes: {
names: string[];
values: string[];
};
classes: string[];
ids: string[];
tags: string[];
undetermined: string[];
}
/**
* @public
*/
export type ExtractorResult = ExtractorResultDetailed | string[];
/**
* @public
*/
export type ExtractorFunction<T = string> = (content: T) => ExtractorResult;
/**
* @public
*/
export interface Extractors {
extensions: string[];
extractor: ExtractorFunction;
}
/**
* @internal
*/
export type IgnoreType = "end" | "start" | "next";
/**
* @public
*/
export type StringRegExpArray = Array<RegExp | string>;
/**
* @public
*/
export type ComplexSafelist = {
standard?: StringRegExpArray;
/**
* You can safelist selectors and their children based on a regular
* expression with `safelist.deep`
*
* @example
*
* ```ts
* const purgecss = await new PurgeCSS().purge({
* content: [],
* css: [],
* safelist: {
* deep: [/red$/]
* }
* })
* ```
*
* In this example, selectors such as `.bg-red .child-of-bg` will be left
* in the final CSS, even if `child-of-bg` is not found.
*
*/
deep?: RegExp[];
greedy?: RegExp[];
variables?: StringRegExpArray;
keyframes?: StringRegExpArray;
};
/**
* @public
*/
export type UserDefinedSafelist = StringRegExpArray | ComplexSafelist;
/**
* Options used by PurgeCSS to remove unused CSS
*
* @public
*/
export interface UserDefinedOptions {
/** {@inheritDoc Options.content} */
content: Array<string | RawContent>;
/** {@inheritDoc Options.css} */
css: Array<string | RawCSS>;
/** {@inheritDoc Options.defaultExtractor} */
defaultExtractor?: ExtractorFunction;
/** {@inheritDoc Options.extractors} */
extractors?: Array<Extractors>;
/** {@inheritDoc Options.fontFace} */
fontFace?: boolean;
/** {@inheritDoc Options.keyframes} */
keyframes?: boolean;
/** {@inheritDoc Options.output} */
output?: string;
/** {@inheritDoc Options.rejected} */
rejected?: boolean;
/** {@inheritDoc Options.rejectedCss} */
rejectedCss?: boolean;
/** {@inheritDoc Options.sourceMap } */
sourceMap?: boolean | postcss.SourceMapOptions & { to?: string }
/** {@inheritDoc Options.stdin} */
stdin?: boolean;
/** {@inheritDoc Options.stdout} */
stdout?: boolean;
/** {@inheritDoc Options.variables} */
variables?: boolean;
/** {@inheritDoc Options.safelist} */
safelist?: UserDefinedSafelist;
/** {@inheritDoc Options.blocklist} */
blocklist?: StringRegExpArray;
/** {@inheritDoc Options.skippedContentGlobs} */
skippedContentGlobs?: Array<string>;
/** {@inheritDoc Options.dynamicAttributes} */
dynamicAttributes?: string[];
}
/**
* Options used by PurgeCSS to remove unused CSS
* Those options are used internally
* @see {@link UserDefinedOptions} for the options defined by the user
*
* @public
*/
export interface Options {
/**
* You can specify content that should be analyzed by PurgeCSS with an
* array of filenames or globs. The files can be HTML, Pug, Blade, etc.
*
* @example
*
* ```ts
* await new PurgeCSS().purge({
* content: ['index.html', '*.js', '*.html', '*.vue'],
* css: ['css/app.css']
* })
* ```
*
* @example
* PurgeCSS also works with raw content. To do this, you need to pass an
* object with the `raw` property instead of a filename. To work properly
* with custom extractors you need to pass the `extension` property along
* with the raw content.
*
* ```ts
* await new PurgeCSS().purge({
* content: [
* {
* raw: '<html><body><div class="app"></div></body></html>',
* extension: 'html'
* },
* '*.js',
* '*.html',
* '*.vue'
* ],
* css: [
* {
* raw: 'body { margin: 0 }'
* },
* 'css/app.css'
* ]
* })
* ```
*/
content: Array<string | RawContent>;
/**
* Similar to content, you can specify css that should be processed by
* PurgeCSS with an array of filenames or globs
*/
css: Array<string | RawCSS>;
defaultExtractor: ExtractorFunction;
extractors: Array<Extractors>;
/**
* If there are any unused \@font-face rules in your css, you can remove
* them by setting the `fontFace` option to `true`.
*
* @defaultValue `false`
*
* @example
* ```ts
* await new PurgeCSS().purge({
* content: ['index.html', '*.js', '*.html', '*.vue'],
* css: ['css/app.css'],
* fontFace: true
* })
* ```
*/
fontFace: boolean;
keyframes: boolean;
output?: string;
rejected: boolean;
rejectedCss: boolean;
/** {@inheritDoc postcss#SourceMapOptions} */
sourceMap: boolean | postcss.SourceMapOptions & { to?: string }
stdin: boolean;
stdout: boolean;
variables: boolean;
/**
* You can indicate which selectors are safe to leave in the final CSS.
* This can be accomplished with the option safelist.
*/
safelist: Required<ComplexSafelist>;
/**
* Blocklist will block the CSS selectors from appearing in the final
* output CSS. The selectors will be removed even when they are seen
* as used by PurgeCSS.
*/
blocklist: StringRegExpArray;
/**
* If you provide globs for the content parameter, you can use this option
* to exclude certain files or folders that would otherwise be scanned.
* Pass an array of globs matching items that should be excluded.
* (Note: this option has no effect if content is not globs.)
*/
skippedContentGlobs: Array<string>;
/**
* Option to add custom CSS attribute selectors like "aria-selected",
* "data-selected", ...etc.
*/
dynamicAttributes: string[];
}
/**
* @public
*/
export interface ResultPurge {
css: string;
/**
* sourceMap property will be empty if
* {@link UserDefinedOptions.sourceMap} inline is not set to false, as the
* source map will be contained within the text of ResultPurge.css
*/
sourceMap?: string;
rejectedCss?: string;
file?: string;
rejected?: string[];
}