You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
808 lines
31 KiB
808 lines
31 KiB
#!/usr/bin/env node
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
const _indexJs = require("../peers/index.js");
|
|
const _chokidar = /*#__PURE__*/ _interopRequireDefault(require("chokidar"));
|
|
const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
|
|
const _arg = /*#__PURE__*/ _interopRequireDefault(require("arg"));
|
|
const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
|
|
const _postcssLoadConfig = /*#__PURE__*/ _interopRequireDefault(require("postcss-load-config"));
|
|
const _lilconfig = require("lilconfig");
|
|
const _plugins = /*#__PURE__*/ _interopRequireDefault(require("postcss-load-config/src/plugins" // Little bit scary, looking at private/internal API
|
|
));
|
|
const _options = /*#__PURE__*/ _interopRequireDefault(require("postcss-load-config/src/options" // Little bit scary, looking at private/internal API
|
|
));
|
|
const _processTailwindFeatures = /*#__PURE__*/ _interopRequireDefault(require("./processTailwindFeatures"));
|
|
const _resolveConfig = /*#__PURE__*/ _interopRequireDefault(require("../resolveConfig"));
|
|
const _fastGlob = /*#__PURE__*/ _interopRequireDefault(require("fast-glob"));
|
|
const _getModuleDependencies = /*#__PURE__*/ _interopRequireDefault(require("./lib/getModuleDependencies"));
|
|
const _log = /*#__PURE__*/ _interopRequireDefault(require("./util/log"));
|
|
const _packageJson = /*#__PURE__*/ _interopRequireDefault(require("../package.json"));
|
|
const _normalizePath = /*#__PURE__*/ _interopRequireDefault(require("normalize-path"));
|
|
const _validateConfigJs = require("./util/validateConfig.js");
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : {
|
|
default: obj
|
|
};
|
|
}
|
|
let env = {
|
|
DEBUG: process.env.DEBUG !== undefined && process.env.DEBUG !== "0"
|
|
};
|
|
function isESM() {
|
|
const pkgPath = _path.default.resolve("./package.json");
|
|
try {
|
|
let pkg = JSON.parse(_fs.default.readFileSync(pkgPath, "utf8"));
|
|
return pkg.type && pkg.type === "module";
|
|
} catch (err) {
|
|
return false;
|
|
}
|
|
}
|
|
let configs = isESM() ? {
|
|
tailwind: "tailwind.config.cjs",
|
|
postcss: "postcss.config.cjs"
|
|
} : {
|
|
tailwind: "tailwind.config.js",
|
|
postcss: "postcss.config.js"
|
|
};
|
|
// ---
|
|
function indentRecursive(node, indent = 0) {
|
|
node.each && node.each((child, i)=>{
|
|
if (!child.raws.before || !child.raws.before.trim() || child.raws.before.includes("\n")) {
|
|
child.raws.before = `\n${node.type !== "rule" && i > 0 ? "\n" : ""}${" ".repeat(indent)}`;
|
|
}
|
|
child.raws.after = `\n${" ".repeat(indent)}`;
|
|
indentRecursive(child, indent + 1);
|
|
});
|
|
}
|
|
function formatNodes(root) {
|
|
indentRecursive(root);
|
|
if (root.first) {
|
|
root.first.raws.before = "";
|
|
}
|
|
}
|
|
async function outputFile(file, contents) {
|
|
if (_fs.default.existsSync(file) && await _fs.default.promises.readFile(file, "utf8") === contents) {
|
|
return; // Skip writing the file
|
|
}
|
|
// Write the file
|
|
await _fs.default.promises.writeFile(file, contents, "utf8");
|
|
}
|
|
function drainStdin() {
|
|
return new Promise((resolve, reject)=>{
|
|
let result = "";
|
|
process.stdin.on("data", (chunk)=>{
|
|
result += chunk;
|
|
});
|
|
process.stdin.on("end", ()=>resolve(result));
|
|
process.stdin.on("error", (err)=>reject(err));
|
|
});
|
|
}
|
|
function help({ message , usage , commands , options }) {
|
|
let indent = 2;
|
|
// Render header
|
|
console.log();
|
|
console.log(`${_packageJson.default.name} v${_packageJson.default.version}`);
|
|
// Render message
|
|
if (message) {
|
|
console.log();
|
|
for (let msg of message.split("\n")){
|
|
console.log(msg);
|
|
}
|
|
}
|
|
// Render usage
|
|
if (usage && usage.length > 0) {
|
|
console.log();
|
|
console.log("Usage:");
|
|
for (let example of usage){
|
|
console.log(" ".repeat(indent), example);
|
|
}
|
|
}
|
|
// Render commands
|
|
if (commands && commands.length > 0) {
|
|
console.log();
|
|
console.log("Commands:");
|
|
for (let command of commands){
|
|
console.log(" ".repeat(indent), command);
|
|
}
|
|
}
|
|
// Render options
|
|
if (options) {
|
|
let groupedOptions = {};
|
|
for (let [key, value] of Object.entries(options)){
|
|
if (typeof value === "object") {
|
|
groupedOptions[key] = {
|
|
...value,
|
|
flags: [
|
|
key
|
|
]
|
|
};
|
|
} else {
|
|
groupedOptions[value].flags.push(key);
|
|
}
|
|
}
|
|
console.log();
|
|
console.log("Options:");
|
|
for (let { flags , description , deprecated } of Object.values(groupedOptions)){
|
|
if (deprecated) continue;
|
|
if (flags.length === 1) {
|
|
console.log(" ".repeat(indent + 4 /* 4 = "-i, ".length */ ), flags.slice().reverse().join(", ").padEnd(20, " "), description);
|
|
} else {
|
|
console.log(" ".repeat(indent), flags.slice().reverse().join(", ").padEnd(24, " "), description);
|
|
}
|
|
}
|
|
}
|
|
console.log();
|
|
}
|
|
function oneOf(...options) {
|
|
return Object.assign((value = true)=>{
|
|
for (let option of options){
|
|
let parsed = option(value);
|
|
if (parsed === value) {
|
|
return parsed;
|
|
}
|
|
}
|
|
throw new Error("...");
|
|
}, {
|
|
manualParsing: true
|
|
});
|
|
}
|
|
function loadPostcss() {
|
|
// Try to load a local `postcss` version first
|
|
try {
|
|
return require("postcss");
|
|
} catch {}
|
|
return (0, _indexJs.lazyPostcss)();
|
|
}
|
|
let commands = {
|
|
init: {
|
|
run: init,
|
|
args: {
|
|
"--full": {
|
|
type: Boolean,
|
|
description: `Initialize a full \`${configs.tailwind}\` file`
|
|
},
|
|
"--postcss": {
|
|
type: Boolean,
|
|
description: `Initialize a \`${configs.postcss}\` file`
|
|
},
|
|
"-f": "--full",
|
|
"-p": "--postcss"
|
|
}
|
|
},
|
|
build: {
|
|
run: build,
|
|
args: {
|
|
"--input": {
|
|
type: String,
|
|
description: "Input file"
|
|
},
|
|
"--output": {
|
|
type: String,
|
|
description: "Output file"
|
|
},
|
|
"--watch": {
|
|
type: Boolean,
|
|
description: "Watch for changes and rebuild as needed"
|
|
},
|
|
"--poll": {
|
|
type: Boolean,
|
|
description: "Use polling instead of filesystem events when watching"
|
|
},
|
|
"--content": {
|
|
type: String,
|
|
description: "Content paths to use for removing unused classes"
|
|
},
|
|
"--purge": {
|
|
type: String,
|
|
deprecated: true
|
|
},
|
|
"--postcss": {
|
|
type: oneOf(String, Boolean),
|
|
description: "Load custom PostCSS configuration"
|
|
},
|
|
"--minify": {
|
|
type: Boolean,
|
|
description: "Minify the output"
|
|
},
|
|
"--config": {
|
|
type: String,
|
|
description: "Path to a custom config file"
|
|
},
|
|
"--no-autoprefixer": {
|
|
type: Boolean,
|
|
description: "Disable autoprefixer"
|
|
},
|
|
"-c": "--config",
|
|
"-i": "--input",
|
|
"-o": "--output",
|
|
"-m": "--minify",
|
|
"-w": "--watch",
|
|
"-p": "--poll"
|
|
}
|
|
}
|
|
};
|
|
let sharedFlags = {
|
|
"--help": {
|
|
type: Boolean,
|
|
description: "Display usage information"
|
|
},
|
|
"-h": "--help"
|
|
};
|
|
if (process.stdout.isTTY /* Detect redirecting output to a file */ && (process.argv[2] === undefined || process.argv.slice(2).every((flag)=>sharedFlags[flag] !== undefined))) {
|
|
help({
|
|
usage: [
|
|
"tailwindcss [--input input.css] [--output output.css] [--watch] [options...]",
|
|
"tailwindcss init [--full] [--postcss] [options...]",
|
|
],
|
|
commands: Object.keys(commands).filter((command)=>command !== "build").map((command)=>`${command} [options]`),
|
|
options: {
|
|
...commands.build.args,
|
|
...sharedFlags
|
|
}
|
|
});
|
|
process.exit(0);
|
|
}
|
|
let command = ((arg = "")=>arg.startsWith("-") ? undefined : arg)(process.argv[2]) || "build";
|
|
if (commands[command] === undefined) {
|
|
if (_fs.default.existsSync(_path.default.resolve(command))) {
|
|
// TODO: Deprecate this in future versions
|
|
// Check if non-existing command, might be a file.
|
|
command = "build";
|
|
} else {
|
|
help({
|
|
message: `Invalid command: ${command}`,
|
|
usage: [
|
|
"tailwindcss <command> [options]"
|
|
],
|
|
commands: Object.keys(commands).filter((command)=>command !== "build").map((command)=>`${command} [options]`),
|
|
options: sharedFlags
|
|
});
|
|
process.exit(1);
|
|
}
|
|
}
|
|
// Execute command
|
|
let { args: flags , run } = commands[command];
|
|
let args = (()=>{
|
|
try {
|
|
let result = (0, _arg.default)(Object.fromEntries(Object.entries({
|
|
...flags,
|
|
...sharedFlags
|
|
}).filter(([_key, value])=>{
|
|
var ref;
|
|
return !(value === null || value === void 0 ? void 0 : (ref = value.type) === null || ref === void 0 ? void 0 : ref.manualParsing);
|
|
}).map(([key, value])=>[
|
|
key,
|
|
typeof value === "object" ? value.type : value
|
|
])), {
|
|
permissive: true
|
|
});
|
|
// Manual parsing of flags to allow for special flags like oneOf(Boolean, String)
|
|
for(let i = result["_"].length - 1; i >= 0; --i){
|
|
let flag = result["_"][i];
|
|
if (!flag.startsWith("-")) continue;
|
|
let flagName = flag;
|
|
let handler = flags[flag];
|
|
// Resolve flagName & handler
|
|
while(typeof handler === "string"){
|
|
flagName = handler;
|
|
handler = flags[handler];
|
|
}
|
|
if (!handler) continue;
|
|
let args = [];
|
|
let offset = i + 1;
|
|
// Parse args for current flag
|
|
while(result["_"][offset] && !result["_"][offset].startsWith("-")){
|
|
args.push(result["_"][offset++]);
|
|
}
|
|
// Cleanup manually parsed flags + args
|
|
result["_"].splice(i, 1 + args.length);
|
|
// Set the resolved value in the `result` object
|
|
result[flagName] = handler.type(args.length === 0 ? undefined : args.length === 1 ? args[0] : args, flagName);
|
|
}
|
|
// Ensure that the `command` is always the first argument in the `args`.
|
|
// This is important so that we don't have to check if a default command
|
|
// (build) was used or not from within each plugin.
|
|
//
|
|
// E.g.: tailwindcss input.css -> _: ['build', 'input.css']
|
|
// E.g.: tailwindcss build input.css -> _: ['build', 'input.css']
|
|
if (result["_"][0] !== command) {
|
|
result["_"].unshift(command);
|
|
}
|
|
return result;
|
|
} catch (err) {
|
|
if (err.code === "ARG_UNKNOWN_OPTION") {
|
|
help({
|
|
message: err.message,
|
|
usage: [
|
|
"tailwindcss <command> [options]"
|
|
],
|
|
options: sharedFlags
|
|
});
|
|
process.exit(1);
|
|
}
|
|
throw err;
|
|
}
|
|
})();
|
|
if (args["--help"]) {
|
|
help({
|
|
options: {
|
|
...flags,
|
|
...sharedFlags
|
|
},
|
|
usage: [
|
|
`tailwindcss ${command} [options]`
|
|
]
|
|
});
|
|
process.exit(0);
|
|
}
|
|
run();
|
|
// ---
|
|
function init() {
|
|
let messages = [];
|
|
var ref;
|
|
let tailwindConfigLocation = _path.default.resolve((ref = args["_"][1]) !== null && ref !== void 0 ? ref : `./${configs.tailwind}`);
|
|
if (_fs.default.existsSync(tailwindConfigLocation)) {
|
|
messages.push(`${_path.default.basename(tailwindConfigLocation)} already exists.`);
|
|
} else {
|
|
let stubFile = _fs.default.readFileSync(args["--full"] ? _path.default.resolve(__dirname, "../stubs/defaultConfig.stub.js") : _path.default.resolve(__dirname, "../stubs/simpleConfig.stub.js"), "utf8");
|
|
// Change colors import
|
|
stubFile = stubFile.replace("../colors", "tailwindcss/colors");
|
|
_fs.default.writeFileSync(tailwindConfigLocation, stubFile, "utf8");
|
|
messages.push(`Created Tailwind CSS config file: ${_path.default.basename(tailwindConfigLocation)}`);
|
|
}
|
|
if (args["--postcss"]) {
|
|
let postcssConfigLocation = _path.default.resolve(`./${configs.postcss}`);
|
|
if (_fs.default.existsSync(postcssConfigLocation)) {
|
|
messages.push(`${_path.default.basename(postcssConfigLocation)} already exists.`);
|
|
} else {
|
|
let stubFile1 = _fs.default.readFileSync(_path.default.resolve(__dirname, "../stubs/defaultPostCssConfig.stub.js"), "utf8");
|
|
_fs.default.writeFileSync(postcssConfigLocation, stubFile1, "utf8");
|
|
messages.push(`Created PostCSS config file: ${_path.default.basename(postcssConfigLocation)}`);
|
|
}
|
|
}
|
|
if (messages.length > 0) {
|
|
console.log();
|
|
for (let message of messages){
|
|
console.log(message);
|
|
}
|
|
}
|
|
}
|
|
async function build() {
|
|
let input = args["--input"];
|
|
let output = args["--output"];
|
|
let shouldWatch = args["--watch"];
|
|
let shouldPoll = args["--poll"];
|
|
let shouldCoalesceWriteEvents = shouldPoll || process.platform === "win32";
|
|
let includePostCss = args["--postcss"];
|
|
// Polling interval in milliseconds
|
|
// Used only when polling or coalescing add/change events on Windows
|
|
let pollInterval = 10;
|
|
// TODO: Deprecate this in future versions
|
|
if (!input && args["_"][1]) {
|
|
console.error("[deprecation] Running tailwindcss without -i, please provide an input file.");
|
|
input = args["--input"] = args["_"][1];
|
|
}
|
|
if (input && input !== "-" && !_fs.default.existsSync(input = _path.default.resolve(input))) {
|
|
console.error(`Specified input file ${args["--input"]} does not exist.`);
|
|
process.exit(9);
|
|
}
|
|
if (args["--config"] && !_fs.default.existsSync(args["--config"] = _path.default.resolve(args["--config"]))) {
|
|
console.error(`Specified config file ${args["--config"]} does not exist.`);
|
|
process.exit(9);
|
|
}
|
|
let configPath = args["--config"] ? args["--config"] : ((defaultPath)=>_fs.default.existsSync(defaultPath) ? defaultPath : null)(_path.default.resolve(`./${configs.tailwind}`));
|
|
async function loadPostCssPlugins() {
|
|
let customPostCssPath = typeof args["--postcss"] === "string" ? args["--postcss"] : undefined;
|
|
let config = customPostCssPath ? await (async ()=>{
|
|
let file = _path.default.resolve(customPostCssPath);
|
|
// Implementation, see: https://unpkg.com/browse/postcss-load-config@3.1.0/src/index.js
|
|
let { config ={} } = await (0, _lilconfig.lilconfig)("postcss").load(file);
|
|
if (typeof config === "function") {
|
|
config = config();
|
|
} else {
|
|
config = Object.assign({}, config);
|
|
}
|
|
if (!config.plugins) {
|
|
config.plugins = [];
|
|
}
|
|
return {
|
|
file,
|
|
plugins: (0, _plugins.default)(config, file),
|
|
options: (0, _options.default)(config, file)
|
|
};
|
|
})() : await (0, _postcssLoadConfig.default)();
|
|
let configPlugins = config.plugins;
|
|
let configPluginTailwindIdx = configPlugins.findIndex((plugin)=>{
|
|
if (typeof plugin === "function" && plugin.name === "tailwindcss") {
|
|
return true;
|
|
}
|
|
if (typeof plugin === "object" && plugin !== null && plugin.postcssPlugin === "tailwindcss") {
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
let beforePlugins = configPluginTailwindIdx === -1 ? [] : configPlugins.slice(0, configPluginTailwindIdx);
|
|
let afterPlugins = configPluginTailwindIdx === -1 ? configPlugins : configPlugins.slice(configPluginTailwindIdx + 1);
|
|
return [
|
|
beforePlugins,
|
|
afterPlugins,
|
|
config.options
|
|
];
|
|
}
|
|
function loadBuiltinPostcssPlugins() {
|
|
let postcss = loadPostcss();
|
|
let IMPORT_COMMENT = "__TAILWIND_RESTORE_IMPORT__: ";
|
|
return [
|
|
[
|
|
(root)=>{
|
|
root.walkAtRules("import", (rule)=>{
|
|
if (rule.params.slice(1).startsWith("tailwindcss/")) {
|
|
rule.after(postcss.comment({
|
|
text: IMPORT_COMMENT + rule.params
|
|
}));
|
|
rule.remove();
|
|
}
|
|
});
|
|
},
|
|
(()=>{
|
|
try {
|
|
return require("postcss-import");
|
|
} catch {}
|
|
return (0, _indexJs.lazyPostcssImport)();
|
|
})(),
|
|
(root)=>{
|
|
root.walkComments((rule)=>{
|
|
if (rule.text.startsWith(IMPORT_COMMENT)) {
|
|
rule.after(postcss.atRule({
|
|
name: "import",
|
|
params: rule.text.replace(IMPORT_COMMENT, "")
|
|
}));
|
|
rule.remove();
|
|
}
|
|
});
|
|
},
|
|
],
|
|
[],
|
|
{},
|
|
];
|
|
}
|
|
function resolveConfig() {
|
|
let config = configPath ? require(configPath) : {};
|
|
if (args["--purge"]) {
|
|
_log.default.warn("purge-flag-deprecated", [
|
|
"The `--purge` flag has been deprecated.",
|
|
"Please use `--content` instead.",
|
|
]);
|
|
if (!args["--content"]) {
|
|
args["--content"] = args["--purge"];
|
|
}
|
|
}
|
|
if (args["--content"]) {
|
|
let files = args["--content"].split(/(?<!{[^}]+),/);
|
|
let resolvedConfig = (0, _resolveConfig.default)(config, {
|
|
content: {
|
|
files
|
|
}
|
|
});
|
|
resolvedConfig.content.files = files;
|
|
resolvedConfig = (0, _validateConfigJs.validateConfig)(resolvedConfig);
|
|
return resolvedConfig;
|
|
}
|
|
let resolvedConfig1 = (0, _resolveConfig.default)(config);
|
|
resolvedConfig1 = (0, _validateConfigJs.validateConfig)(resolvedConfig1);
|
|
return resolvedConfig1;
|
|
}
|
|
function extractFileGlobs(config) {
|
|
return config.content.files.filter((file)=>{
|
|
// Strings in this case are files / globs. If it is something else,
|
|
// like an object it's probably a raw content object. But this object
|
|
// is not watchable, so let's remove it.
|
|
return typeof file === "string";
|
|
}).map((glob)=>(0, _normalizePath.default)(glob));
|
|
}
|
|
function extractRawContent(config) {
|
|
return config.content.files.filter((file)=>{
|
|
return typeof file === "object" && file !== null;
|
|
});
|
|
}
|
|
function getChangedContent(config) {
|
|
let changedContent = [];
|
|
// Resolve globs from the content config
|
|
let globs = extractFileGlobs(config);
|
|
let files = _fastGlob.default.sync(globs);
|
|
for (let file of files){
|
|
changedContent.push({
|
|
content: _fs.default.readFileSync(_path.default.resolve(file), "utf8"),
|
|
extension: _path.default.extname(file).slice(1)
|
|
});
|
|
}
|
|
// Resolve raw content in the tailwind config
|
|
for (let { raw: content , extension ="html" } of extractRawContent(config)){
|
|
changedContent.push({
|
|
content,
|
|
extension
|
|
});
|
|
}
|
|
return changedContent;
|
|
}
|
|
async function buildOnce() {
|
|
let config = resolveConfig();
|
|
let changedContent = getChangedContent(config);
|
|
let tailwindPlugin = ()=>{
|
|
return {
|
|
postcssPlugin: "tailwindcss",
|
|
Once (root, { result }) {
|
|
(0, _processTailwindFeatures.default)(({ createContext })=>{
|
|
return ()=>{
|
|
return createContext(config, changedContent);
|
|
};
|
|
})(root, result);
|
|
}
|
|
};
|
|
};
|
|
tailwindPlugin.postcss = true;
|
|
let [beforePlugins, afterPlugins, postcssOptions] = includePostCss ? await loadPostCssPlugins() : loadBuiltinPostcssPlugins();
|
|
let plugins = [
|
|
...beforePlugins,
|
|
tailwindPlugin,
|
|
!args["--minify"] && formatNodes,
|
|
...afterPlugins,
|
|
!args["--no-autoprefixer"] && (()=>{
|
|
// Try to load a local `autoprefixer` version first
|
|
try {
|
|
return require("autoprefixer");
|
|
} catch {}
|
|
return (0, _indexJs.lazyAutoprefixer)();
|
|
})(),
|
|
args["--minify"] && (()=>{
|
|
let options = {
|
|
preset: [
|
|
"default",
|
|
{
|
|
cssDeclarationSorter: false
|
|
}
|
|
]
|
|
};
|
|
// Try to load a local `cssnano` version first
|
|
try {
|
|
return require("cssnano");
|
|
} catch {}
|
|
return (0, _indexJs.lazyCssnano)()(options);
|
|
})(),
|
|
].filter(Boolean);
|
|
let postcss = loadPostcss();
|
|
let processor = postcss(plugins);
|
|
function processCSS(css) {
|
|
let start = process.hrtime.bigint();
|
|
return Promise.resolve().then(()=>output ? _fs.default.promises.mkdir(_path.default.dirname(output), {
|
|
recursive: true
|
|
}) : null).then(()=>processor.process(css, {
|
|
...postcssOptions,
|
|
from: input,
|
|
to: output
|
|
})).then((result)=>{
|
|
if (!output) {
|
|
return process.stdout.write(result.css);
|
|
}
|
|
return Promise.all([
|
|
outputFile(output, result.css),
|
|
result.map && outputFile(output + ".map", result.map.toString()),
|
|
].filter(Boolean));
|
|
}).then(()=>{
|
|
let end = process.hrtime.bigint();
|
|
console.error();
|
|
console.error("Done in", (end - start) / BigInt(1e6) + "ms.");
|
|
});
|
|
}
|
|
let css = await (()=>{
|
|
// Piping in data, let's drain the stdin
|
|
if (input === "-") {
|
|
return drainStdin();
|
|
}
|
|
// Input file has been provided
|
|
if (input) {
|
|
return _fs.default.readFileSync(_path.default.resolve(input), "utf8");
|
|
}
|
|
// No input file provided, fallback to default atrules
|
|
return "@tailwind base; @tailwind components; @tailwind utilities";
|
|
})();
|
|
return processCSS(css);
|
|
}
|
|
let context = null;
|
|
async function startWatcher() {
|
|
let changedContent = [];
|
|
let configDependencies = [];
|
|
let contextDependencies = new Set();
|
|
let watcher = null;
|
|
function refreshConfig() {
|
|
env.DEBUG && console.time("Module dependencies");
|
|
for (let file of configDependencies){
|
|
delete require.cache[require.resolve(file)];
|
|
}
|
|
if (configPath) {
|
|
configDependencies = (0, _getModuleDependencies.default)(configPath).map(({ file })=>file);
|
|
for (let dependency of configDependencies){
|
|
contextDependencies.add(dependency);
|
|
}
|
|
}
|
|
env.DEBUG && console.timeEnd("Module dependencies");
|
|
return resolveConfig();
|
|
}
|
|
let [beforePlugins, afterPlugins] = includePostCss ? await loadPostCssPlugins() : loadBuiltinPostcssPlugins();
|
|
let plugins = [
|
|
...beforePlugins,
|
|
"__TAILWIND_PLUGIN_POSITION__",
|
|
!args["--minify"] && formatNodes,
|
|
...afterPlugins,
|
|
!args["--no-autoprefixer"] && (()=>{
|
|
// Try to load a local `autoprefixer` version first
|
|
try {
|
|
return require("autoprefixer");
|
|
} catch {}
|
|
return (0, _indexJs.lazyAutoprefixer)();
|
|
})(),
|
|
args["--minify"] && (()=>{
|
|
let options = {
|
|
preset: [
|
|
"default",
|
|
{
|
|
cssDeclarationSorter: false
|
|
}
|
|
]
|
|
};
|
|
// Try to load a local `cssnano` version first
|
|
try {
|
|
return require("cssnano");
|
|
} catch {}
|
|
return (0, _indexJs.lazyCssnano)()(options);
|
|
})(),
|
|
].filter(Boolean);
|
|
async function rebuild(config) {
|
|
env.DEBUG && console.time("Finished in");
|
|
let tailwindPlugin = ()=>{
|
|
return {
|
|
postcssPlugin: "tailwindcss",
|
|
Once (root, { result }) {
|
|
env.DEBUG && console.time("Compiling CSS");
|
|
(0, _processTailwindFeatures.default)(({ createContext })=>{
|
|
console.error();
|
|
console.error("Rebuilding...");
|
|
return ()=>{
|
|
if (context !== null) {
|
|
context.changedContent = changedContent.splice(0);
|
|
return context;
|
|
}
|
|
env.DEBUG && console.time("Creating context");
|
|
context = createContext(config, changedContent.splice(0));
|
|
env.DEBUG && console.timeEnd("Creating context");
|
|
return context;
|
|
};
|
|
})(root, result);
|
|
env.DEBUG && console.timeEnd("Compiling CSS");
|
|
}
|
|
};
|
|
};
|
|
tailwindPlugin.postcss = true;
|
|
let tailwindPluginIdx = plugins.indexOf("__TAILWIND_PLUGIN_POSITION__");
|
|
let copy = plugins.slice();
|
|
copy.splice(tailwindPluginIdx, 1, tailwindPlugin);
|
|
let postcss = loadPostcss();
|
|
let processor = postcss(copy);
|
|
function processCSS(css) {
|
|
let start = process.hrtime.bigint();
|
|
return Promise.resolve().then(()=>output ? _fs.default.promises.mkdir(_path.default.dirname(output), {
|
|
recursive: true
|
|
}) : null).then(()=>processor.process(css, {
|
|
from: input,
|
|
to: output
|
|
})).then(async (result)=>{
|
|
for (let message of result.messages){
|
|
if (message.type === "dependency") {
|
|
contextDependencies.add(message.file);
|
|
}
|
|
}
|
|
watcher.add([
|
|
...contextDependencies
|
|
]);
|
|
if (!output) {
|
|
return process.stdout.write(result.css);
|
|
}
|
|
return Promise.all([
|
|
outputFile(output, result.css),
|
|
result.map && outputFile(output + ".map", result.map.toString()),
|
|
].filter(Boolean));
|
|
}).then(()=>{
|
|
let end = process.hrtime.bigint();
|
|
console.error("Done in", (end - start) / BigInt(1e6) + "ms.");
|
|
}).catch((err)=>{
|
|
if (err.name === "CssSyntaxError") {
|
|
console.error(err.toString());
|
|
} else {
|
|
console.error(err);
|
|
}
|
|
});
|
|
}
|
|
let css = await (()=>{
|
|
// Piping in data, let's drain the stdin
|
|
if (input === "-") {
|
|
return drainStdin();
|
|
}
|
|
// Input file has been provided
|
|
if (input) {
|
|
return _fs.default.readFileSync(_path.default.resolve(input), "utf8");
|
|
}
|
|
// No input file provided, fallback to default atrules
|
|
return "@tailwind base; @tailwind components; @tailwind utilities";
|
|
})();
|
|
let result = await processCSS(css);
|
|
env.DEBUG && console.timeEnd("Finished in");
|
|
return result;
|
|
}
|
|
let config = refreshConfig(configPath);
|
|
if (input) {
|
|
contextDependencies.add(_path.default.resolve(input));
|
|
}
|
|
watcher = _chokidar.default.watch([
|
|
...contextDependencies,
|
|
...extractFileGlobs(config)
|
|
], {
|
|
usePolling: shouldPoll,
|
|
interval: shouldPoll ? pollInterval : undefined,
|
|
ignoreInitial: true,
|
|
awaitWriteFinish: shouldCoalesceWriteEvents ? {
|
|
stabilityThreshold: 50,
|
|
pollInterval: pollInterval
|
|
} : false
|
|
});
|
|
let chain = Promise.resolve();
|
|
watcher.on("change", async (file)=>{
|
|
if (contextDependencies.has(file)) {
|
|
env.DEBUG && console.time("Resolve config");
|
|
context = null;
|
|
config = refreshConfig(configPath);
|
|
env.DEBUG && console.timeEnd("Resolve config");
|
|
env.DEBUG && console.time("Watch new files");
|
|
let globs = extractFileGlobs(config);
|
|
watcher.add(configDependencies);
|
|
watcher.add(globs);
|
|
env.DEBUG && console.timeEnd("Watch new files");
|
|
chain = chain.then(async ()=>{
|
|
changedContent.push(...getChangedContent(config));
|
|
await rebuild(config);
|
|
});
|
|
} else {
|
|
chain = chain.then(async ()=>{
|
|
changedContent.push({
|
|
content: _fs.default.readFileSync(_path.default.resolve(file), "utf8"),
|
|
extension: _path.default.extname(file).slice(1)
|
|
});
|
|
await rebuild(config);
|
|
});
|
|
}
|
|
});
|
|
watcher.on("add", async (file)=>{
|
|
chain = chain.then(async ()=>{
|
|
changedContent.push({
|
|
content: _fs.default.readFileSync(_path.default.resolve(file), "utf8"),
|
|
extension: _path.default.extname(file).slice(1)
|
|
});
|
|
await rebuild(config);
|
|
});
|
|
});
|
|
chain = chain.then(()=>{
|
|
changedContent.push(...getChangedContent(config));
|
|
return rebuild(config);
|
|
});
|
|
}
|
|
if (shouldWatch) {
|
|
/* Abort the watcher if stdin is closed to avoid zombie processes */ if (process.stdin.isTTY) {
|
|
process.stdin.on("end", ()=>process.exit(0));
|
|
process.stdin.resume();
|
|
}
|
|
startWatcher();
|
|
} else {
|
|
buildOnce();
|
|
}
|
|
}
|