@master/css-compiler 2.0.0-beta.99 → 2.0.0-rc.70
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +34 -133
- package/dist/browser.d.ts +22 -0
- package/dist/browser.mjs +47 -0
- package/dist/core.d.ts +48 -0
- package/dist/core.mjs +2019 -0
- package/dist/css-transform.d.ts +6 -0
- package/dist/css-transform.mjs +18 -0
- package/dist/index.d.ts +46 -3
- package/dist/index.mjs +394 -10
- package/dist/lexer/imports.d.ts +13 -0
- package/dist/lexer/imports.mjs +44 -0
- package/dist/lexer/source.d.ts +3 -0
- package/dist/lexer/source.mjs +9 -0
- package/dist/lexer/standalone-master.d.ts +21 -0
- package/dist/lexer/standalone-master.mjs +233 -0
- package/dist/lower-css-directives.d.ts +16 -0
- package/dist/lower-css-directives.mjs +969 -0
- package/dist/master-css-manifest.d.ts +14 -0
- package/dist/master-css-manifest.mjs +760 -0
- package/dist/native-declaration.d.ts +2 -0
- package/dist/native-declaration.mjs +25 -0
- package/dist/utils/selectors.d.ts +3 -0
- package/dist/utils/selectors.mjs +55 -0
- package/dist/utils/unquote.d.ts +1 -0
- package/dist/utils/unquote.mjs +10 -0
- package/dist/utils/wrap-at-rules.d.ts +1 -0
- package/dist/utils/wrap-at-rules.mjs +10 -0
- package/package.json +1 -1
- package/dist/compiler.d.ts +0 -19
- package/dist/extract.d.ts +0 -3
- package/dist/index.cjs +0 -10
- package/dist/options/index.d.ts +0 -17
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
import type * as LightningCSS from 'lightningcss';
|
|
2
|
+
export type CSSTransform = typeof LightningCSS.transform;
|
|
3
|
+
export declare function setCSSTransform(transformer: CSSTransform): void;
|
|
4
|
+
export declare function getCSSTransform(): typeof LightningCSS.transform;
|
|
5
|
+
export declare function encodeCSS(source: string): Uint8Array<ArrayBuffer>;
|
|
6
|
+
export declare function decodeCSS(code: Uint8Array): string;
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
let transform;
|
|
2
|
+
function setCSSTransform(transformer) {
|
|
3
|
+
transform = transformer;
|
|
4
|
+
}
|
|
5
|
+
function getCSSTransform() {
|
|
6
|
+
if (!transform) {
|
|
7
|
+
throw new Error('@master/css-compiler requires a CSS transform implementation. Use the default Node entry or initialize the browser entry.');
|
|
8
|
+
}
|
|
9
|
+
return transform;
|
|
10
|
+
}
|
|
11
|
+
function encodeCSS(source) {
|
|
12
|
+
return new TextEncoder().encode(source);
|
|
13
|
+
}
|
|
14
|
+
function decodeCSS(code) {
|
|
15
|
+
return new TextDecoder().decode(code);
|
|
16
|
+
}
|
|
17
|
+
|
|
18
|
+
export { decodeCSS, encodeCSS, getCSSTransform, setCSSTransform };
|
package/dist/index.d.ts
CHANGED
|
@@ -1,3 +1,46 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
export
|
|
1
|
+
import type { MasterCSSManifest } from '@master/css-schema/manifest';
|
|
2
|
+
import { type CompileCSSOptions, type CSSReferenceStatement, type CompileCSSFileOptions, type CompileCSSResult, type ResolvedCSSImportGraph } from './core';
|
|
3
|
+
export * from './core';
|
|
4
|
+
export type { CompileCSSFileOptions, CompileCSSOptions, CompileCSSResult, CSSReferenceStatement, ResolvedCSSImportGraph, StandaloneCSSDirectiveStatement, StandaloneMasterDirectiveStatement } from './core';
|
|
5
|
+
export interface InspectCSSResult {
|
|
6
|
+
hasMasterEntryDirective: boolean;
|
|
7
|
+
hasMasterCSSImport: boolean;
|
|
8
|
+
hasMasterEntry: boolean;
|
|
9
|
+
}
|
|
10
|
+
export interface ResolveCSSImportGraphOptions {
|
|
11
|
+
projectDir?: string;
|
|
12
|
+
expandPackageImports?: boolean;
|
|
13
|
+
onReference?: (reference: CSSReferenceStatement, fromFile: string) => void;
|
|
14
|
+
}
|
|
15
|
+
export type CompileCSSManifestOptions = CompileCSSFileOptions & {
|
|
16
|
+
baseManifest?: MasterCSSManifest;
|
|
17
|
+
};
|
|
18
|
+
export type CompileCSSManifestSourceOptions = CompileCSSOptions & {
|
|
19
|
+
baseManifest?: MasterCSSManifest;
|
|
20
|
+
root?: string;
|
|
21
|
+
};
|
|
22
|
+
export interface CompileCSSManifestResult extends Omit<CompileCSSResult, 'manifestInput'> {
|
|
23
|
+
manifest: MasterCSSManifest;
|
|
24
|
+
directives: CompileCSSResult;
|
|
25
|
+
}
|
|
26
|
+
export interface CompileProjectManifestResult extends CompileCSSManifestResult {
|
|
27
|
+
entries: string[];
|
|
28
|
+
}
|
|
29
|
+
export type CompileCSSManifestJSONResult = CompileCSSManifestResult & {
|
|
30
|
+
json: string;
|
|
31
|
+
directives: CompileCSSResult;
|
|
32
|
+
};
|
|
33
|
+
export declare function resolveMasterCSSPackageEntryFile(importSource: string, fromFile?: string, projectDir?: string): string | undefined;
|
|
34
|
+
export declare function inspectCSS(source: string): InspectCSSResult;
|
|
35
|
+
export declare function resolveCSSImportGraph(file: string, options?: ResolveCSSImportGraphOptions): ResolvedCSSImportGraph;
|
|
36
|
+
export declare function resolveMasterCSSPackageImportGraph(projectDir?: string): ResolvedCSSImportGraph;
|
|
37
|
+
export declare function isMasterCSSPackageStyleFile(id: string, projectDir?: string): boolean;
|
|
38
|
+
export declare function compileCSSFile(file: string, options?: CompileCSSFileOptions): CompileCSSResult;
|
|
39
|
+
export declare function createManifestFromCSSResult(result: CompileCSSResult, options?: CompileCSSManifestSourceOptions): CompileCSSManifestResult;
|
|
40
|
+
export declare function compileCSSManifest(source: string, options?: CompileCSSManifestSourceOptions): CompileCSSManifestResult;
|
|
41
|
+
export declare function compileCSSManifestFile(file: string, options?: CompileCSSManifestOptions): CompileCSSManifestResult;
|
|
42
|
+
export declare function compileProjectManifest(entries: string[], options?: CompileCSSManifestOptions): CompileProjectManifestResult;
|
|
43
|
+
export declare function compileCSSManifestJSON(file: string, options?: CompileCSSManifestOptions): CompileCSSManifestJSONResult;
|
|
44
|
+
export declare function compileProjectManifestJSON(entries: string[], options?: CompileCSSManifestOptions): CompileProjectManifestResult & {
|
|
45
|
+
json: string;
|
|
46
|
+
};
|
package/dist/index.mjs
CHANGED
|
@@ -1,10 +1,394 @@
|
|
|
1
|
-
import
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
1
|
+
import { existsSync, realpathSync, readFileSync } from 'node:fs';
|
|
2
|
+
import { createRequire } from 'node:module';
|
|
3
|
+
import { isAbsolute, resolve, extname, dirname } from 'node:path';
|
|
4
|
+
import { transform } from 'lightningcss';
|
|
5
|
+
import { stringifyMasterCSSManifestJSON } from '@master/css-schema/manifest-json';
|
|
6
|
+
import { createMasterCSSManifest } from './master-css-manifest.mjs';
|
|
7
|
+
import lowerCSSDirectives from './lower-css-directives.mjs';
|
|
8
|
+
import { compileCSS, findCSSReferenceStatements, removeCSSReferenceStatements } from './core.mjs';
|
|
9
|
+
export { maskManagedPatternEntryNames, parseDirectives } from './core.mjs';
|
|
10
|
+
import { removeCSSImportStatements, findCSSImportStatements, replaceCSSImportStatements } from './lexer/imports.mjs';
|
|
11
|
+
import { mergeCSSDirectiveExtractionPolicy, findStandaloneMasterDirectiveStatements, createCSSDirectiveExtractionPolicy } from './lexer/standalone-master.mjs';
|
|
12
|
+
export { collectStandaloneCSSDirectiveExtractionPolicy, findStandaloneCSSDirectiveStatements, removeStandaloneCSSDirectives, removeStandaloneMasterDirectives } from './lexer/standalone-master.mjs';
|
|
13
|
+
import { setCSSTransform } from './css-transform.mjs';
|
|
14
|
+
|
|
15
|
+
setCSSTransform(transform);
|
|
16
|
+
const require$1 = createRequire(import.meta.url);
|
|
17
|
+
const MASTER_CSS_PACKAGE_ID = '@master/css';
|
|
18
|
+
const MASTER_CSS_PACKAGE_IDS = new Set([
|
|
19
|
+
MASTER_CSS_PACKAGE_ID,
|
|
20
|
+
'@master/css-preset'
|
|
21
|
+
]);
|
|
22
|
+
function isExpandableImportSource(source) {
|
|
23
|
+
return (source.startsWith('./') || source.startsWith('../')) && extname(source) === '.css';
|
|
24
|
+
}
|
|
25
|
+
function readJSONFile(file) {
|
|
26
|
+
return JSON.parse(readFileSync(file, 'utf-8'));
|
|
27
|
+
}
|
|
28
|
+
function findPackageRoot(entryFile, packageName) {
|
|
29
|
+
let directory = dirname(entryFile);
|
|
30
|
+
while(true){
|
|
31
|
+
const packageJSONFile = resolve(directory, 'package.json');
|
|
32
|
+
if (existsSync(packageJSONFile)) {
|
|
33
|
+
try {
|
|
34
|
+
const packageJSON = readJSONFile(packageJSONFile);
|
|
35
|
+
if (packageJSON.name === packageName) {
|
|
36
|
+
return {
|
|
37
|
+
directory,
|
|
38
|
+
packageJSON
|
|
39
|
+
};
|
|
40
|
+
}
|
|
41
|
+
} catch {
|
|
42
|
+
// Keep walking up in case this is not the package root.
|
|
43
|
+
}
|
|
44
|
+
}
|
|
45
|
+
const parentDirectory = dirname(directory);
|
|
46
|
+
if (parentDirectory === directory) return;
|
|
47
|
+
directory = parentDirectory;
|
|
48
|
+
}
|
|
49
|
+
}
|
|
50
|
+
function getPackageStyleEntry(packageJSON) {
|
|
51
|
+
if (typeof packageJSON.style === 'string') return packageJSON.style;
|
|
52
|
+
if (!packageJSON.exports || typeof packageJSON.exports !== 'object') return;
|
|
53
|
+
const rootExport = packageJSON.exports['.'];
|
|
54
|
+
if (!rootExport || typeof rootExport !== 'object') return;
|
|
55
|
+
const styleExport = rootExport.style;
|
|
56
|
+
return typeof styleExport === 'string' ? styleExport : undefined;
|
|
57
|
+
}
|
|
58
|
+
function createProjectRequire(fromFile, projectDir) {
|
|
59
|
+
return createRequire(resolve(projectDir || dirname(fromFile), 'package.json'));
|
|
60
|
+
}
|
|
61
|
+
function resolveMasterCSSPackageEntryFile(importSource, fromFile = process.cwd(), projectDir) {
|
|
62
|
+
if (!MASTER_CSS_PACKAGE_IDS.has(importSource)) return;
|
|
63
|
+
const resolver = createProjectRequire(fromFile, projectDir);
|
|
64
|
+
let packageEntryFile;
|
|
65
|
+
try {
|
|
66
|
+
packageEntryFile = resolver.resolve(importSource);
|
|
67
|
+
} catch {
|
|
68
|
+
packageEntryFile = require$1.resolve(importSource);
|
|
69
|
+
}
|
|
70
|
+
const packageRoot = findPackageRoot(packageEntryFile, importSource);
|
|
71
|
+
if (!packageRoot) return;
|
|
72
|
+
const styleEntry = getPackageStyleEntry(packageRoot.packageJSON);
|
|
73
|
+
if (!styleEntry) return;
|
|
74
|
+
const styleFile = resolve(packageRoot.directory, styleEntry);
|
|
75
|
+
if (!existsSync(styleFile)) {
|
|
76
|
+
throw new Error(`${importSource} CSS style entry was not found: ${styleFile}`);
|
|
77
|
+
}
|
|
78
|
+
return styleFile;
|
|
79
|
+
}
|
|
80
|
+
function inspectCSS(source) {
|
|
81
|
+
const hasMasterEntryDirective = findStandaloneMasterDirectiveStatements(source).some((statement)=>statement.name === '');
|
|
82
|
+
const hasMasterCSSImport = findCSSImportStatements(source).some((statement)=>statement.source === MASTER_CSS_PACKAGE_ID);
|
|
83
|
+
return {
|
|
84
|
+
hasMasterEntryDirective,
|
|
85
|
+
hasMasterCSSImport,
|
|
86
|
+
hasMasterEntry: hasMasterEntryDirective || hasMasterCSSImport
|
|
87
|
+
};
|
|
88
|
+
}
|
|
89
|
+
function resolveCSSImportGraphFile(file, dependencies, dependencySet, stack, options = {}) {
|
|
90
|
+
const absoluteFile = resolve(file);
|
|
91
|
+
if (stack.includes(absoluteFile)) {
|
|
92
|
+
throw new Error(`Circular CSS import: ${[
|
|
93
|
+
...stack,
|
|
94
|
+
absoluteFile
|
|
95
|
+
].join(' -> ')}`);
|
|
96
|
+
}
|
|
97
|
+
if (!existsSync(absoluteFile)) {
|
|
98
|
+
throw new Error(`CSS manifest entry file not found: ${absoluteFile}`);
|
|
99
|
+
}
|
|
100
|
+
if (!dependencySet.has(absoluteFile)) {
|
|
101
|
+
dependencySet.add(absoluteFile);
|
|
102
|
+
dependencies.push(absoluteFile);
|
|
103
|
+
}
|
|
104
|
+
const source = readFileSync(absoluteFile, 'utf-8');
|
|
105
|
+
const references = findCSSReferenceStatements(source, absoluteFile);
|
|
106
|
+
for (const reference of references){
|
|
107
|
+
options.onReference?.(reference, absoluteFile);
|
|
108
|
+
}
|
|
109
|
+
const sourceWithoutReferences = removeCSSReferenceStatements(source, absoluteFile);
|
|
110
|
+
const imports = findCSSImportStatements(sourceWithoutReferences, absoluteFile);
|
|
111
|
+
if (!imports.length) return sourceWithoutReferences;
|
|
112
|
+
const preservedImports = [];
|
|
113
|
+
const resolvedSource = replaceCSSImportStatements(sourceWithoutReferences, absoluteFile, (importStatement)=>{
|
|
114
|
+
const importSource = importStatement.source;
|
|
115
|
+
const packageFile = options.expandPackageImports !== false ? resolveMasterCSSPackageEntryFile(importSource, absoluteFile, options.projectDir) : undefined;
|
|
116
|
+
if (packageFile || isExpandableImportSource(importSource)) {
|
|
117
|
+
const importedFile = packageFile || resolve(dirname(absoluteFile), importSource);
|
|
118
|
+
return resolveCSSImportGraphFile(importedFile, dependencies, dependencySet, [
|
|
119
|
+
...stack,
|
|
120
|
+
absoluteFile
|
|
121
|
+
], options);
|
|
122
|
+
}
|
|
123
|
+
preservedImports.push(importStatement.statement.trim());
|
|
124
|
+
return '';
|
|
125
|
+
});
|
|
126
|
+
if (!preservedImports.length) return resolvedSource;
|
|
127
|
+
const firstImportStart = imports[0].start;
|
|
128
|
+
const afterImports = resolvedSource.slice(firstImportStart);
|
|
129
|
+
return resolvedSource.slice(0, firstImportStart) + preservedImports.join('\n') + (afterImports ? '\n' : '') + afterImports;
|
|
130
|
+
}
|
|
131
|
+
function resolveCSSImportGraph(file, options = {}) {
|
|
132
|
+
const dependencies = [];
|
|
133
|
+
const references = [];
|
|
134
|
+
const source = resolveCSSImportGraphFile(file, dependencies, new Set(), [], {
|
|
135
|
+
...options,
|
|
136
|
+
onReference (reference, fromFile) {
|
|
137
|
+
references.push(reference);
|
|
138
|
+
options.onReference?.(reference, fromFile);
|
|
139
|
+
}
|
|
140
|
+
});
|
|
141
|
+
return {
|
|
142
|
+
source,
|
|
143
|
+
dependencies,
|
|
144
|
+
...references.length ? {
|
|
145
|
+
references
|
|
146
|
+
} : {}
|
|
147
|
+
};
|
|
148
|
+
}
|
|
149
|
+
function resolveMasterCSSPackageImportGraph(projectDir) {
|
|
150
|
+
const entry = resolveMasterCSSPackageEntryFile(MASTER_CSS_PACKAGE_ID, projectDir || process.cwd(), projectDir);
|
|
151
|
+
if (!entry) {
|
|
152
|
+
throw new Error(`Cannot resolve ${MASTER_CSS_PACKAGE_ID} CSS entry.`);
|
|
153
|
+
}
|
|
154
|
+
return resolveCSSImportGraph(entry, {
|
|
155
|
+
projectDir
|
|
156
|
+
});
|
|
157
|
+
}
|
|
158
|
+
function stripRequest(id) {
|
|
159
|
+
return id.replace(/[?#].*$/, '');
|
|
160
|
+
}
|
|
161
|
+
function resolveComparablePath(file) {
|
|
162
|
+
const filename = resolve(file);
|
|
163
|
+
try {
|
|
164
|
+
return realpathSync(filename);
|
|
165
|
+
} catch {
|
|
166
|
+
return filename;
|
|
167
|
+
}
|
|
168
|
+
}
|
|
169
|
+
function isMasterCSSPackageStyleFile(id, projectDir) {
|
|
170
|
+
const filename = resolveComparablePath(stripRequest(id));
|
|
171
|
+
if (extname(filename) !== '.css') return false;
|
|
172
|
+
try {
|
|
173
|
+
return resolveMasterCSSPackageImportGraph(projectDir).dependencies.some((dependency)=>{
|
|
174
|
+
return resolveComparablePath(dependency) === filename;
|
|
175
|
+
});
|
|
176
|
+
} catch {
|
|
177
|
+
return false;
|
|
178
|
+
}
|
|
179
|
+
}
|
|
180
|
+
function compileCSSFile(file, options = {}) {
|
|
181
|
+
const { root, ...compileOptions } = options;
|
|
182
|
+
const absoluteFile = isAbsolute(file) ? file : resolve(root || '', file);
|
|
183
|
+
const graph = resolveCSSImportGraph(absoluteFile, {
|
|
184
|
+
projectDir: root
|
|
185
|
+
});
|
|
186
|
+
const source = compileOptions.preserveNativeCSS === false ? removeCSSImportStatements(graph.source, absoluteFile) : graph.source;
|
|
187
|
+
const result = compileCSS(source, {
|
|
188
|
+
...compileOptions,
|
|
189
|
+
from: absoluteFile
|
|
190
|
+
});
|
|
191
|
+
return {
|
|
192
|
+
...result,
|
|
193
|
+
dependencies: graph.dependencies,
|
|
194
|
+
...graph.references?.length ? {
|
|
195
|
+
references: graph.references
|
|
196
|
+
} : {}
|
|
197
|
+
};
|
|
198
|
+
}
|
|
199
|
+
function addUnique(target, values) {
|
|
200
|
+
if (!values) return;
|
|
201
|
+
for (const value of values){
|
|
202
|
+
if (!target.includes(value)) target.push(value);
|
|
203
|
+
}
|
|
204
|
+
}
|
|
205
|
+
function resolveCSSReferenceFile(reference, options = {}) {
|
|
206
|
+
const fromFile = reference.file ? isAbsolute(reference.file) ? reference.file : resolve(options.root || '', reference.file) : resolve(options.root || process.cwd(), 'master.css');
|
|
207
|
+
const packageFile = resolveMasterCSSPackageEntryFile(reference.source, fromFile, options.root);
|
|
208
|
+
if (packageFile) return packageFile;
|
|
209
|
+
if (isExpandableImportSource(reference.source)) return resolve(dirname(fromFile), reference.source);
|
|
210
|
+
throw new Error(`@reference only supports relative CSS files or Master CSS package entries: ${reference.source}`);
|
|
211
|
+
}
|
|
212
|
+
function normalizeReferenceStack(stack) {
|
|
213
|
+
return (stack || []).map((file)=>resolveComparablePath(file));
|
|
214
|
+
}
|
|
215
|
+
function resolveCSSReferenceContext(references, options = {}) {
|
|
216
|
+
const dependencies = [];
|
|
217
|
+
const warnings = [];
|
|
218
|
+
let manifest = options.baseManifest;
|
|
219
|
+
let hasReferences = false;
|
|
220
|
+
for (const reference of references || []){
|
|
221
|
+
const referenceFile = resolveCSSReferenceFile(reference, options);
|
|
222
|
+
const comparableReferenceFile = resolveComparablePath(referenceFile);
|
|
223
|
+
const stack = normalizeReferenceStack(options.referenceStack);
|
|
224
|
+
if (stack.includes(comparableReferenceFile)) {
|
|
225
|
+
throw new Error(`Circular CSS reference: ${[
|
|
226
|
+
...options.referenceStack || [],
|
|
227
|
+
referenceFile
|
|
228
|
+
].join(' -> ')}`);
|
|
229
|
+
}
|
|
230
|
+
const result = compileCSSManifestFileInternal(referenceFile, {
|
|
231
|
+
...options,
|
|
232
|
+
baseManifest: manifest,
|
|
233
|
+
preserveNativeCSS: false,
|
|
234
|
+
referenceStack: options.referenceStack
|
|
235
|
+
});
|
|
236
|
+
hasReferences = true;
|
|
237
|
+
manifest = result.manifest;
|
|
238
|
+
addUnique(dependencies, result.dependencies);
|
|
239
|
+
addUnique(warnings, result.warnings);
|
|
240
|
+
}
|
|
241
|
+
return {
|
|
242
|
+
dependencies,
|
|
243
|
+
warnings,
|
|
244
|
+
...hasReferences ? {
|
|
245
|
+
manifest
|
|
246
|
+
} : {}
|
|
247
|
+
};
|
|
248
|
+
}
|
|
249
|
+
function toCompileCSSManifestResult(result, options = {}) {
|
|
250
|
+
const { manifestInput: _directiveManifestInput, ...directiveData } = result;
|
|
251
|
+
const referenceContext = resolveCSSReferenceContext(result.references, options);
|
|
252
|
+
const lowerResult = lowerCSSDirectives(result, {
|
|
253
|
+
baseManifest: options.baseManifest,
|
|
254
|
+
resolutionManifest: referenceContext.manifest,
|
|
255
|
+
onWarning: options.onWarning
|
|
256
|
+
});
|
|
257
|
+
const dependencies = [];
|
|
258
|
+
const warnings = [];
|
|
259
|
+
addUnique(dependencies, result.dependencies);
|
|
260
|
+
addUnique(dependencies, referenceContext.dependencies);
|
|
261
|
+
addUnique(warnings, referenceContext.warnings);
|
|
262
|
+
addUnique(warnings, lowerResult.warnings);
|
|
263
|
+
const generatedCSS = lowerResult.generatedCSS || '';
|
|
264
|
+
const css = [
|
|
265
|
+
result.nativeCSS,
|
|
266
|
+
generatedCSS
|
|
267
|
+
].filter(Boolean).join('\n');
|
|
268
|
+
return {
|
|
269
|
+
...directiveData,
|
|
270
|
+
dependencies,
|
|
271
|
+
manifest: lowerResult.manifest,
|
|
272
|
+
warnings,
|
|
273
|
+
generatedCSS,
|
|
274
|
+
css,
|
|
275
|
+
directives: result
|
|
276
|
+
};
|
|
277
|
+
}
|
|
278
|
+
function createManifestFromCSSResult(result, options = {}) {
|
|
279
|
+
return toCompileCSSManifestResult(result, options);
|
|
280
|
+
}
|
|
281
|
+
function compileCSSManifest(source, options = {}) {
|
|
282
|
+
const from = options.from ? stripRequest(options.from) : undefined;
|
|
283
|
+
const fromFile = from ? isAbsolute(from) ? from : resolve(options.root || '', from) : undefined;
|
|
284
|
+
const result = compileCSS(source, {
|
|
285
|
+
...options,
|
|
286
|
+
...fromFile ? {
|
|
287
|
+
from: fromFile
|
|
288
|
+
} : {}
|
|
289
|
+
});
|
|
290
|
+
return toCompileCSSManifestResult(result, {
|
|
291
|
+
...options,
|
|
292
|
+
...fromFile ? {
|
|
293
|
+
from: fromFile,
|
|
294
|
+
referenceStack: [
|
|
295
|
+
...options.referenceStack || [],
|
|
296
|
+
fromFile
|
|
297
|
+
]
|
|
298
|
+
} : {}
|
|
299
|
+
});
|
|
300
|
+
}
|
|
301
|
+
function compileCSSManifestFileInternal(file, options = {}) {
|
|
302
|
+
const absoluteFile = isAbsolute(file) ? file : resolve(options.root || '', file);
|
|
303
|
+
const result = compileCSSFile(file, {
|
|
304
|
+
...options,
|
|
305
|
+
preserveNativeCSS: options.preserveNativeCSS ?? false
|
|
306
|
+
});
|
|
307
|
+
return toCompileCSSManifestResult(result, {
|
|
308
|
+
...options,
|
|
309
|
+
from: absoluteFile,
|
|
310
|
+
referenceStack: [
|
|
311
|
+
...options.referenceStack || [],
|
|
312
|
+
absoluteFile
|
|
313
|
+
]
|
|
314
|
+
});
|
|
315
|
+
}
|
|
316
|
+
function compileCSSManifestFile(file, options = {}) {
|
|
317
|
+
return compileCSSManifestFileInternal(file, options);
|
|
318
|
+
}
|
|
319
|
+
function compileProjectManifest(entries, options = {}) {
|
|
320
|
+
const dependencies = [];
|
|
321
|
+
let extractionPolicy = createCSSDirectiveExtractionPolicy();
|
|
322
|
+
const classNames = [];
|
|
323
|
+
const nativeClassNames = [];
|
|
324
|
+
const nativeCSS = [];
|
|
325
|
+
const css = [];
|
|
326
|
+
const generatedCSS = [];
|
|
327
|
+
const warnings = [];
|
|
328
|
+
let directives = {
|
|
329
|
+
manifestInput: {},
|
|
330
|
+
extractionPolicy: createCSSDirectiveExtractionPolicy(),
|
|
331
|
+
classNames: [],
|
|
332
|
+
nativeClassNames: [],
|
|
333
|
+
nativeCSS: '',
|
|
334
|
+
css: '',
|
|
335
|
+
generatedCSS: '',
|
|
336
|
+
warnings: [],
|
|
337
|
+
dependencies: []
|
|
338
|
+
};
|
|
339
|
+
let manifest = options.baseManifest;
|
|
340
|
+
for (const entry of entries){
|
|
341
|
+
const result = compileCSSFile(entry, {
|
|
342
|
+
...options,
|
|
343
|
+
preserveNativeCSS: options.preserveNativeCSS ?? false
|
|
344
|
+
});
|
|
345
|
+
directives = result;
|
|
346
|
+
extractionPolicy = mergeCSSDirectiveExtractionPolicy(extractionPolicy, result.extractionPolicy);
|
|
347
|
+
addUnique(dependencies, result.dependencies);
|
|
348
|
+
addUnique(classNames, result.classNames);
|
|
349
|
+
addUnique(nativeClassNames, result.nativeClassNames);
|
|
350
|
+
addUnique(warnings, result.warnings);
|
|
351
|
+
const manifestResult = toCompileCSSManifestResult(result, {
|
|
352
|
+
...options,
|
|
353
|
+
baseManifest: manifest,
|
|
354
|
+
from: entry,
|
|
355
|
+
referenceStack: [
|
|
356
|
+
isAbsolute(entry) ? entry : resolve(options.root || '', entry)
|
|
357
|
+
]
|
|
358
|
+
});
|
|
359
|
+
manifest = manifestResult.manifest;
|
|
360
|
+
addUnique(dependencies, manifestResult.dependencies);
|
|
361
|
+
addUnique(warnings, manifestResult.warnings);
|
|
362
|
+
const entryGeneratedCSS = manifestResult.generatedCSS || '';
|
|
363
|
+
if (result.nativeCSS) nativeCSS.push(result.nativeCSS);
|
|
364
|
+
if (entryGeneratedCSS) generatedCSS.push(entryGeneratedCSS);
|
|
365
|
+
if (manifestResult.css) css.push(manifestResult.css);
|
|
366
|
+
}
|
|
367
|
+
return {
|
|
368
|
+
entries,
|
|
369
|
+
manifest: manifest || createMasterCSSManifest(),
|
|
370
|
+
dependencies,
|
|
371
|
+
extractionPolicy,
|
|
372
|
+
classNames,
|
|
373
|
+
nativeClassNames,
|
|
374
|
+
nativeCSS: nativeCSS.join('\n'),
|
|
375
|
+
css: css.join('\n'),
|
|
376
|
+
generatedCSS: generatedCSS.join('\n'),
|
|
377
|
+
warnings,
|
|
378
|
+
directives
|
|
379
|
+
};
|
|
380
|
+
}
|
|
381
|
+
function toManifestJSONResult(result) {
|
|
382
|
+
return {
|
|
383
|
+
...result,
|
|
384
|
+
json: stringifyMasterCSSManifestJSON(result.manifest)
|
|
385
|
+
};
|
|
386
|
+
}
|
|
387
|
+
function compileCSSManifestJSON(file, options = {}) {
|
|
388
|
+
return toManifestJSONResult(compileCSSManifestFile(file, options));
|
|
389
|
+
}
|
|
390
|
+
function compileProjectManifestJSON(entries, options = {}) {
|
|
391
|
+
return toManifestJSONResult(compileProjectManifest(entries, options));
|
|
392
|
+
}
|
|
393
|
+
|
|
394
|
+
export { compileCSS, compileCSSFile, compileCSSManifest, compileCSSManifestFile, compileCSSManifestJSON, compileProjectManifest, compileProjectManifestJSON, createCSSDirectiveExtractionPolicy, createManifestFromCSSResult, findCSSReferenceStatements, findStandaloneMasterDirectiveStatements, inspectCSS, isMasterCSSPackageStyleFile, mergeCSSDirectiveExtractionPolicy, removeCSSReferenceStatements, resolveCSSImportGraph, resolveMasterCSSPackageEntryFile, resolveMasterCSSPackageImportGraph, setCSSTransform };
|
|
@@ -0,0 +1,13 @@
|
|
|
1
|
+
import type { Rule } from 'lightningcss';
|
|
2
|
+
export interface CSSImportStatement {
|
|
3
|
+
start: number;
|
|
4
|
+
end: number;
|
|
5
|
+
source: string;
|
|
6
|
+
statement: string;
|
|
7
|
+
rule: Extract<Rule, {
|
|
8
|
+
type: 'import';
|
|
9
|
+
}>;
|
|
10
|
+
}
|
|
11
|
+
export declare function findCSSImportStatements(source: string, filename?: string): CSSImportStatement[];
|
|
12
|
+
export declare function removeCSSImportStatements(source: string, filename?: string): string;
|
|
13
|
+
export declare function replaceCSSImportStatements(source: string, filename: string, getReplacement: (statement: CSSImportStatement) => string | undefined): string;
|
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
import { getCSSTransform, encodeCSS } from '../css-transform.mjs';
|
|
2
|
+
import { maskManagedPatternEntryNames } from '../core.mjs';
|
|
3
|
+
import { findAtRuleStatementEnd } from './source.mjs';
|
|
4
|
+
import { createSourceLocationResolver, removeSourceRanges, replaceSourceRanges } from '@master/css-lexer';
|
|
5
|
+
|
|
6
|
+
function findCSSImportStatements(source, filename = 'master.css') {
|
|
7
|
+
const statements = [];
|
|
8
|
+
const maskedSource = maskManagedPatternEntryNames(source);
|
|
9
|
+
const resolveLocation = createSourceLocationResolver(maskedSource);
|
|
10
|
+
getCSSTransform()({
|
|
11
|
+
filename,
|
|
12
|
+
code: encodeCSS(maskedSource),
|
|
13
|
+
visitor: {
|
|
14
|
+
Rule: {
|
|
15
|
+
import (rule) {
|
|
16
|
+
const start = resolveLocation(rule.value.loc);
|
|
17
|
+
if (start === -1) return;
|
|
18
|
+
const end = findAtRuleStatementEnd(source, start);
|
|
19
|
+
if (end === -1) return;
|
|
20
|
+
statements.push({
|
|
21
|
+
start,
|
|
22
|
+
end,
|
|
23
|
+
source: rule.value.url,
|
|
24
|
+
statement: source.slice(start, end),
|
|
25
|
+
rule
|
|
26
|
+
});
|
|
27
|
+
}
|
|
28
|
+
}
|
|
29
|
+
}
|
|
30
|
+
});
|
|
31
|
+
return statements;
|
|
32
|
+
}
|
|
33
|
+
function removeCSSImportStatements(source, filename = 'master.css') {
|
|
34
|
+
return removeSourceRanges(source, findCSSImportStatements(source, filename));
|
|
35
|
+
}
|
|
36
|
+
function replaceCSSImportStatements(source, filename, getReplacement) {
|
|
37
|
+
const replacements = findCSSImportStatements(source, filename).map((statement)=>({
|
|
38
|
+
...statement,
|
|
39
|
+
replacement: getReplacement(statement) ?? statement.statement
|
|
40
|
+
}));
|
|
41
|
+
return replaceSourceRanges(source, replacements);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
export { findCSSImportStatements, removeCSSImportStatements, replaceCSSImportStatements };
|
|
@@ -0,0 +1,3 @@
|
|
|
1
|
+
import { createSourceLocationResolver, removeSourceRanges, replaceSourceRanges, type SourceRange } from '@master/css-lexer';
|
|
2
|
+
export { createSourceLocationResolver, removeSourceRanges, replaceSourceRanges, type SourceRange };
|
|
3
|
+
export declare function findAtRuleStatementEnd(source: string, start: number): number;
|
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
import { findCSSStatementEnd } from '@master/css-lexer';
|
|
2
|
+
export { createSourceLocationResolver, removeSourceRanges, replaceSourceRanges } from '@master/css-lexer';
|
|
3
|
+
|
|
4
|
+
function findAtRuleStatementEnd(source, start) {
|
|
5
|
+
const statementEnd = findCSSStatementEnd(source, start);
|
|
6
|
+
return statementEnd.reason === 'semicolon' ? statementEnd.end : -1;
|
|
7
|
+
}
|
|
8
|
+
|
|
9
|
+
export { findAtRuleStatementEnd };
|
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
import type { CSSDirectiveExtractionPolicy } from '@master/css-schema/css-directives';
|
|
2
|
+
export type StandaloneCSSDirectiveName = 'master' | 'source' | 'safelist' | 'blocklist' | 'preserve';
|
|
3
|
+
export interface StandaloneCSSDirectiveStatement {
|
|
4
|
+
start: number;
|
|
5
|
+
end: number;
|
|
6
|
+
atRuleName: StandaloneCSSDirectiveName;
|
|
7
|
+
name: string;
|
|
8
|
+
statement: string;
|
|
9
|
+
args: string[];
|
|
10
|
+
modifiers: string[];
|
|
11
|
+
}
|
|
12
|
+
export type StandaloneMasterDirectiveStatement = StandaloneCSSDirectiveStatement & {
|
|
13
|
+
atRuleName: 'master';
|
|
14
|
+
};
|
|
15
|
+
export declare function createCSSDirectiveExtractionPolicy(): CSSDirectiveExtractionPolicy;
|
|
16
|
+
export declare function mergeCSSDirectiveExtractionPolicy(...policies: (Partial<CSSDirectiveExtractionPolicy> | undefined)[]): CSSDirectiveExtractionPolicy;
|
|
17
|
+
export declare function findStandaloneCSSDirectiveStatements(source: string, filename?: string): StandaloneCSSDirectiveStatement[];
|
|
18
|
+
export declare function findStandaloneMasterDirectiveStatements(source: string, filename?: string): StandaloneMasterDirectiveStatement[];
|
|
19
|
+
export declare function collectStandaloneCSSDirectiveExtractionPolicy(source: string, filename?: string): CSSDirectiveExtractionPolicy;
|
|
20
|
+
export declare function removeStandaloneCSSDirectives(source: string, filename?: string): string;
|
|
21
|
+
export declare function removeStandaloneMasterDirectives(source: string, filename?: string): string;
|