@master/css-compiler 2.0.0-rc.73 → 2.0.0-rc.75

package/dist/css-transform.mjs

@@ -1,18 +0,0 @@
-let transform;
-function setCSSTransform(transformer) {
-    transform = transformer;
-}
-function getCSSTransform() {
-    if (!transform) {
-        throw new Error('@master/css-compiler requires a CSS transform implementation. Use the default Node entry or initialize the browser entry.');
-    }
-    return transform;
-}
-function encodeCSS(source) {
-    return new TextEncoder().encode(source);
-}
-function decodeCSS(code) {
-    return new TextDecoder().decode(code);
-}
-
-export { decodeCSS, encodeCSS, getCSSTransform, setCSSTransform };

package/dist/index.mjs

@@ -1,395 +0,0 @@
-import { existsSync, realpathSync, readFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { isAbsolute, resolve, extname, dirname } from 'node:path';
-import { transform } from 'lightningcss';
-import { stringifyMasterCSSManifestJSON } from '@master/css-schema/manifest-json';
-import { MASTER_CSS_ENTRY_DIRECTIVE_NAME } from '@master/css-lexer';
-import { createMasterCSSManifest } from './master-css-manifest.mjs';
-import lowerCSSDirectives from './lower-css-directives.mjs';
-import { compileCSS, findCSSReferenceStatements, removeCSSReferenceStatements } from './core.mjs';
-export { maskManagedPatternEntryNames, parseDirectives } from './core.mjs';
-import { removeCSSImportStatements, findCSSImportStatements, replaceCSSImportStatements } from './lexer/imports.mjs';
-import { mergeCSSDirectiveExtractionPolicy, findStandaloneMasterDirectiveStatements, createCSSDirectiveExtractionPolicy } from './lexer/standalone-master.mjs';
-export { collectStandaloneCSSDirectiveExtractionPolicy, findStandaloneCSSDirectiveStatements, removeStandaloneCSSDirectives, removeStandaloneMasterDirectives } from './lexer/standalone-master.mjs';
-import { setCSSTransform } from './css-transform.mjs';
-
-setCSSTransform(transform);
-const require$1 = createRequire(import.meta.url);
-const MASTER_CSS_PACKAGE_ID = '@master/css';
-const MASTER_CSS_PACKAGE_IDS = new Set([
-    MASTER_CSS_PACKAGE_ID,
-    '@master/css-preset'
-]);
-function isExpandableImportSource(source) {
-    return (source.startsWith('./') || source.startsWith('../')) && extname(source) === '.css';
-}
-function readJSONFile(file) {
-    return JSON.parse(readFileSync(file, 'utf-8'));
-}
-function findPackageRoot(entryFile, packageName) {
-    let directory = dirname(entryFile);
-    while(true){
-        const packageJSONFile = resolve(directory, 'package.json');
-        if (existsSync(packageJSONFile)) {
-            try {
-                const packageJSON = readJSONFile(packageJSONFile);
-                if (packageJSON.name === packageName) {
-                    return {
-                        directory,
-                        packageJSON
-                    };
-                }
-            } catch  {
-            // Keep walking up in case this is not the package root.
-            }
-        }
-        const parentDirectory = dirname(directory);
-        if (parentDirectory === directory) return;
-        directory = parentDirectory;
-    }
-}
-function getPackageStyleEntry(packageJSON) {
-    if (typeof packageJSON.style === 'string') return packageJSON.style;
-    if (!packageJSON.exports || typeof packageJSON.exports !== 'object') return;
-    const rootExport = packageJSON.exports['.'];
-    if (!rootExport || typeof rootExport !== 'object') return;
-    const styleExport = rootExport.style;
-    return typeof styleExport === 'string' ? styleExport : undefined;
-}
-function createProjectRequire(fromFile, projectDir) {
-    return createRequire(resolve(projectDir || dirname(fromFile), 'package.json'));
-}
-function resolveMasterCSSPackageEntryFile(importSource, fromFile = process.cwd(), projectDir) {
-    if (!MASTER_CSS_PACKAGE_IDS.has(importSource)) return;
-    const resolver = createProjectRequire(fromFile, projectDir);
-    let packageEntryFile;
-    try {
-        packageEntryFile = resolver.resolve(importSource);
-    } catch  {
-        packageEntryFile = require$1.resolve(importSource);
-    }
-    const packageRoot = findPackageRoot(packageEntryFile, importSource);
-    if (!packageRoot) return;
-    const styleEntry = getPackageStyleEntry(packageRoot.packageJSON);
-    if (!styleEntry) return;
-    const styleFile = resolve(packageRoot.directory, styleEntry);
-    if (!existsSync(styleFile)) {
-        throw new Error(`${importSource} CSS style entry was not found: ${styleFile}`);
-    }
-    return styleFile;
-}
-function inspectCSS(source) {
-    const hasMasterEntryDirective = findStandaloneMasterDirectiveStatements(source).some((statement)=>statement.name === MASTER_CSS_ENTRY_DIRECTIVE_NAME);
-    const hasMasterCSSImport = findCSSImportStatements(source).some((statement)=>statement.source === MASTER_CSS_PACKAGE_ID);
-    return {
-        hasMasterEntryDirective,
-        hasMasterCSSImport,
-        hasMasterEntry: hasMasterEntryDirective || hasMasterCSSImport
-    };
-}
-function resolveCSSImportGraphFile(file, dependencies, dependencySet, stack, options = {}) {
-    const absoluteFile = resolve(file);
-    if (stack.includes(absoluteFile)) {
-        throw new Error(`Circular CSS import: ${[
-            ...stack,
-            absoluteFile
-        ].join(' -> ')}`);
-    }
-    if (!existsSync(absoluteFile)) {
-        throw new Error(`CSS manifest entry file not found: ${absoluteFile}`);
-    }
-    if (!dependencySet.has(absoluteFile)) {
-        dependencySet.add(absoluteFile);
-        dependencies.push(absoluteFile);
-    }
-    const source = readFileSync(absoluteFile, 'utf-8');
-    const references = findCSSReferenceStatements(source, absoluteFile);
-    for (const reference of references){
-        options.onReference?.(reference, absoluteFile);
-    }
-    const sourceWithoutReferences = removeCSSReferenceStatements(source, absoluteFile);
-    const imports = findCSSImportStatements(sourceWithoutReferences, absoluteFile);
-    if (!imports.length) return sourceWithoutReferences;
-    const preservedImports = [];
-    const resolvedSource = replaceCSSImportStatements(sourceWithoutReferences, absoluteFile, (importStatement)=>{
-        const importSource = importStatement.source;
-        const packageFile = options.expandPackageImports !== false ? resolveMasterCSSPackageEntryFile(importSource, absoluteFile, options.projectDir) : undefined;
-        if (packageFile || isExpandableImportSource(importSource)) {
-            const importedFile = packageFile || resolve(dirname(absoluteFile), importSource);
-            return resolveCSSImportGraphFile(importedFile, dependencies, dependencySet, [
-                ...stack,
-                absoluteFile
-            ], options);
-        }
-        preservedImports.push(importStatement.statement.trim());
-        return '';
-    });
-    if (!preservedImports.length) return resolvedSource;
-    const firstImportStart = imports[0].start;
-    const afterImports = resolvedSource.slice(firstImportStart);
-    return resolvedSource.slice(0, firstImportStart) + preservedImports.join('\n') + (afterImports ? '\n' : '') + afterImports;
-}
-function resolveCSSImportGraph(file, options = {}) {
-    const dependencies = [];
-    const references = [];
-    const source = resolveCSSImportGraphFile(file, dependencies, new Set(), [], {
-        ...options,
-        onReference (reference, fromFile) {
-            references.push(reference);
-            options.onReference?.(reference, fromFile);
-        }
-    });
-    return {
-        source,
-        dependencies,
-        ...references.length ? {
-            references
-        } : {}
-    };
-}
-function resolveMasterCSSPackageImportGraph(projectDir) {
-    const entry = resolveMasterCSSPackageEntryFile(MASTER_CSS_PACKAGE_ID, projectDir || process.cwd(), projectDir);
-    if (!entry) {
-        throw new Error(`Cannot resolve ${MASTER_CSS_PACKAGE_ID} CSS entry.`);
-    }
-    return resolveCSSImportGraph(entry, {
-        projectDir
-    });
-}
-function stripRequest(id) {
-    return id.replace(/[?#].*$/, '');
-}
-function resolveComparablePath(file) {
-    const filename = resolve(file);
-    try {
-        return realpathSync(filename);
-    } catch  {
-        return filename;
-    }
-}
-function isMasterCSSPackageStyleFile(id, projectDir) {
-    const filename = resolveComparablePath(stripRequest(id));
-    if (extname(filename) !== '.css') return false;
-    try {
-        return resolveMasterCSSPackageImportGraph(projectDir).dependencies.some((dependency)=>{
-            return resolveComparablePath(dependency) === filename;
-        });
-    } catch  {
-        return false;
-    }
-}
-function compileCSSFile(file, options = {}) {
-    const { root, ...compileOptions } = options;
-    const absoluteFile = isAbsolute(file) ? file : resolve(root || '', file);
-    const graph = resolveCSSImportGraph(absoluteFile, {
-        projectDir: root
-    });
-    const source = compileOptions.preserveNativeCSS === false ? removeCSSImportStatements(graph.source, absoluteFile) : graph.source;
-    const result = compileCSS(source, {
-        ...compileOptions,
-        from: absoluteFile
-    });
-    return {
-        ...result,
-        dependencies: graph.dependencies,
-        ...graph.references?.length ? {
-            references: graph.references
-        } : {}
-    };
-}
-function addUnique(target, values) {
-    if (!values) return;
-    for (const value of values){
-        if (!target.includes(value)) target.push(value);
-    }
-}
-function resolveCSSReferenceFile(reference, options = {}) {
-    const fromFile = reference.file ? isAbsolute(reference.file) ? reference.file : resolve(options.root || '', reference.file) : resolve(options.root || process.cwd(), 'master.css');
-    const packageFile = resolveMasterCSSPackageEntryFile(reference.source, fromFile, options.root);
-    if (packageFile) return packageFile;
-    if (isExpandableImportSource(reference.source)) return resolve(dirname(fromFile), reference.source);
-    throw new Error(`@reference only supports relative CSS files or Master CSS package entries: ${reference.source}`);
-}
-function normalizeReferenceStack(stack) {
-    return (stack || []).map((file)=>resolveComparablePath(file));
-}
-function resolveCSSReferenceContext(references, options = {}) {
-    const dependencies = [];
-    const warnings = [];
-    let manifest = options.baseManifest;
-    let hasReferences = false;
-    for (const reference of references || []){
-        const referenceFile = resolveCSSReferenceFile(reference, options);
-        const comparableReferenceFile = resolveComparablePath(referenceFile);
-        const stack = normalizeReferenceStack(options.referenceStack);
-        if (stack.includes(comparableReferenceFile)) {
-            throw new Error(`Circular CSS reference: ${[
-                ...options.referenceStack || [],
-                referenceFile
-            ].join(' -> ')}`);
-        }
-        const result = compileCSSManifestFileInternal(referenceFile, {
-            ...options,
-            baseManifest: manifest,
-            preserveNativeCSS: false,
-            referenceStack: options.referenceStack
-        });
-        hasReferences = true;
-        manifest = result.manifest;
-        addUnique(dependencies, result.dependencies);
-        addUnique(warnings, result.warnings);
-    }
-    return {
-        dependencies,
-        warnings,
-        ...hasReferences ? {
-            manifest
-        } : {}
-    };
-}
-function toCompileCSSManifestResult(result, options = {}) {
-    const { manifestInput: _directiveManifestInput, ...directiveData } = result;
-    const referenceContext = resolveCSSReferenceContext(result.references, options);
-    const lowerResult = lowerCSSDirectives(result, {
-        baseManifest: options.baseManifest,
-        resolutionManifest: referenceContext.manifest,
-        onWarning: options.onWarning
-    });
-    const dependencies = [];
-    const warnings = [];
-    addUnique(dependencies, result.dependencies);
-    addUnique(dependencies, referenceContext.dependencies);
-    addUnique(warnings, referenceContext.warnings);
-    addUnique(warnings, lowerResult.warnings);
-    const generatedCSS = lowerResult.generatedCSS || '';
-    const css = [
-        result.nativeCSS,
-        generatedCSS
-    ].filter(Boolean).join('\n');
-    return {
-        ...directiveData,
-        dependencies,
-        manifest: lowerResult.manifest,
-        warnings,
-        generatedCSS,
-        css,
-        directives: result
-    };
-}
-function createManifestFromCSSResult(result, options = {}) {
-    return toCompileCSSManifestResult(result, options);
-}
-function compileCSSManifest(source, options = {}) {
-    const from = options.from ? stripRequest(options.from) : undefined;
-    const fromFile = from ? isAbsolute(from) ? from : resolve(options.root || '', from) : undefined;
-    const result = compileCSS(source, {
-        ...options,
-        ...fromFile ? {
-            from: fromFile
-        } : {}
-    });
-    return toCompileCSSManifestResult(result, {
-        ...options,
-        ...fromFile ? {
-            from: fromFile,
-            referenceStack: [
-                ...options.referenceStack || [],
-                fromFile
-            ]
-        } : {}
-    });
-}
-function compileCSSManifestFileInternal(file, options = {}) {
-    const absoluteFile = isAbsolute(file) ? file : resolve(options.root || '', file);
-    const result = compileCSSFile(file, {
-        ...options,
-        preserveNativeCSS: options.preserveNativeCSS ?? false
-    });
-    return toCompileCSSManifestResult(result, {
-        ...options,
-        from: absoluteFile,
-        referenceStack: [
-            ...options.referenceStack || [],
-            absoluteFile
-        ]
-    });
-}
-function compileCSSManifestFile(file, options = {}) {
-    return compileCSSManifestFileInternal(file, options);
-}
-function compileProjectManifest(entries, options = {}) {
-    const dependencies = [];
-    let extractionPolicy = createCSSDirectiveExtractionPolicy();
-    const classNames = [];
-    const nativeClassNames = [];
-    const nativeCSS = [];
-    const css = [];
-    const generatedCSS = [];
-    const warnings = [];
-    let directives = {
-        manifestInput: {},
-        extractionPolicy: createCSSDirectiveExtractionPolicy(),
-        classNames: [],
-        nativeClassNames: [],
-        nativeCSS: '',
-        css: '',
-        generatedCSS: '',
-        warnings: [],
-        dependencies: []
-    };
-    let manifest = options.baseManifest;
-    for (const entry of entries){
-        const result = compileCSSFile(entry, {
-            ...options,
-            preserveNativeCSS: options.preserveNativeCSS ?? false
-        });
-        directives = result;
-        extractionPolicy = mergeCSSDirectiveExtractionPolicy(extractionPolicy, result.extractionPolicy);
-        addUnique(dependencies, result.dependencies);
-        addUnique(classNames, result.classNames);
-        addUnique(nativeClassNames, result.nativeClassNames);
-        addUnique(warnings, result.warnings);
-        const manifestResult = toCompileCSSManifestResult(result, {
-            ...options,
-            baseManifest: manifest,
-            from: entry,
-            referenceStack: [
-                isAbsolute(entry) ? entry : resolve(options.root || '', entry)
-            ]
-        });
-        manifest = manifestResult.manifest;
-        addUnique(dependencies, manifestResult.dependencies);
-        addUnique(warnings, manifestResult.warnings);
-        const entryGeneratedCSS = manifestResult.generatedCSS || '';
-        if (result.nativeCSS) nativeCSS.push(result.nativeCSS);
-        if (entryGeneratedCSS) generatedCSS.push(entryGeneratedCSS);
-        if (manifestResult.css) css.push(manifestResult.css);
-    }
-    return {
-        entries,
-        manifest: manifest || createMasterCSSManifest(),
-        dependencies,
-        extractionPolicy,
-        classNames,
-        nativeClassNames,
-        nativeCSS: nativeCSS.join('\n'),
-        css: css.join('\n'),
-        generatedCSS: generatedCSS.join('\n'),
-        warnings,
-        directives
-    };
-}
-function toManifestJSONResult(result) {
-    return {
-        ...result,
-        json: stringifyMasterCSSManifestJSON(result.manifest)
-    };
-}
-function compileCSSManifestJSON(file, options = {}) {
-    return toManifestJSONResult(compileCSSManifestFile(file, options));
-}
-function compileProjectManifestJSON(entries, options = {}) {
-    return toManifestJSONResult(compileProjectManifest(entries, options));
-}
-
-export { compileCSS, compileCSSFile, compileCSSManifest, compileCSSManifestFile, compileCSSManifestJSON, compileProjectManifest, compileProjectManifestJSON, createCSSDirectiveExtractionPolicy, createManifestFromCSSResult, findCSSReferenceStatements, findStandaloneMasterDirectiveStatements, inspectCSS, isMasterCSSPackageStyleFile, mergeCSSDirectiveExtractionPolicy, removeCSSReferenceStatements, resolveCSSImportGraph, resolveMasterCSSPackageEntryFile, resolveMasterCSSPackageImportGraph, setCSSTransform };

package/dist/lexer/imports.mjs

@@ -1,44 +0,0 @@
-import { getCSSTransform, encodeCSS } from '../css-transform.mjs';
-import { maskManagedPatternEntryNames } from '../core.mjs';
-import { findAtRuleStatementEnd } from './source.mjs';
-import { createSourceLocationResolver, removeSourceRanges, replaceSourceRanges } from '@master/css-lexer';
-
-function findCSSImportStatements(source, filename = 'master.css') {
-    const statements = [];
-    const maskedSource = maskManagedPatternEntryNames(source);
-    const resolveLocation = createSourceLocationResolver(maskedSource);
-    getCSSTransform()({
-        filename,
-        code: encodeCSS(maskedSource),
-        visitor: {
-            Rule: {
-                import (rule) {
-                    const start = resolveLocation(rule.value.loc);
-                    if (start === -1) return;
-                    const end = findAtRuleStatementEnd(source, start);
-                    if (end === -1) return;
-                    statements.push({
-                        start,
-                        end,
-                        source: rule.value.url,
-                        statement: source.slice(start, end),
-                        rule
-                    });
-                }
-            }
-        }
-    });
-    return statements;
-}
-function removeCSSImportStatements(source, filename = 'master.css') {
-    return removeSourceRanges(source, findCSSImportStatements(source, filename));
-}
-function replaceCSSImportStatements(source, filename, getReplacement) {
-    const replacements = findCSSImportStatements(source, filename).map((statement)=>({
-            ...statement,
-            replacement: getReplacement(statement) ?? statement.statement
-        }));
-    return replaceSourceRanges(source, replacements);
-}
-
-export { findCSSImportStatements, removeCSSImportStatements, replaceCSSImportStatements };

package/dist/lexer/source.mjs

@@ -1,9 +0,0 @@
-import { findCSSStatementEnd } from '@master/css-lexer';
-export { createSourceLocationResolver, removeSourceRanges, replaceSourceRanges } from '@master/css-lexer';
-
-function findAtRuleStatementEnd(source, start) {
-    const statementEnd = findCSSStatementEnd(source, start);
-    return statementEnd.reason === 'semicolon' ? statementEnd.end : -1;
-}
-
-export { findAtRuleStatementEnd };