Fix the XCSS.saveToFile function: import fs from 'fs'; class XCSS { static compile(code:…
- User
Fix the XCSS.saveToFile function:
import fs from 'fs';
class XCSS { static compile(code: string): string { // Stores function definitions const functions: Record<string, { params: string[], body: string[] }> = {};
// Split the code into lines for processing const lines = code.split(/\r?\n/); // Root block to hold all top-level CSS const rootBlock: { selector: string, declarations: string[], children: any[] } = { selector: '', declarations: [], children: [] }; let currentBlock = rootBlock; // Stack to keep track of nested blocks const blockStack = [rootBlock]; // Flags for parsing functions let inFunction = false; let currentFunctionName = ''; let currentFunctionParams: string[] = []; let currentFunctionBody: string[] = []; for (let line of lines) { line = line.trim(); if (line === '') { continue; // Skip empty lines } if (line.startsWith('@import')) { // Handle @import directives currentBlock.declarations.push(line + ';'); } else if (line.startsWith('@function')) { // Start of a function definition const funcMatch = line.match(/@function\s+([^(]+)\(([^)]*)\)\s*{/); if (funcMatch) { inFunction = true; currentFunctionName = funcMatch[1].trim(); currentFunctionParams = funcMatch[2].split(',').map(p => p.trim()); currentFunctionBody = []; } } else if (inFunction) { if (line === '}') { // End of function definition, store it functions[currentFunctionName] = { params: currentFunctionParams, body: currentFunctionBody, }; inFunction = false; currentFunctionName = ''; currentFunctionParams = []; currentFunctionBody = []; } else { // Accumulate function body lines currentFunctionBody.push(line); } } else if (line.startsWith('@include')) { // Handle @include directives const includeMatch = line.match(/@include\s+([^(]+)\(([^)]*)\);?/); if (includeMatch) { const includeName = includeMatch[1].trim(); const includeArgs = includeMatch[2].split(',').map(a => a.trim().replace(/['"]/g, '')); const func = functions[includeName]; if (func) { const paramValues: Record<string, string> = {}; func.params.forEach((param, index) => { paramValues[param] = includeArgs[index] || ''; }); // Replace variables in the function body and add to current block for (let funcLine of func.body) { let processedLine = funcLine; for (const [param, value] of Object.entries(paramValues)) { const regex = new RegExp('\\' + param + '\\b', 'g'); processedLine = processedLine.replace(regex, value); } currentBlock.declarations.push(processedLine); } } else { console.error(`Function ${includeName} not defined.`); } } } else if (line.endsWith('{')) { // Start of a new block const selector = line.slice(0, -1).trim(); const newBlock: { selector: string, declarations: string[], children: any[] } = { selector, declarations: [], children: [] }; currentBlock.children.push(newBlock); blockStack.push(newBlock); currentBlock = newBlock; } else if (line === '}') { // End of the current block blockStack.pop(); currentBlock = blockStack[blockStack.length - 1]; } else { // Add declarations to the current block currentBlock.declarations.push(line); } } // Now, generate the final CSS from the block tree const outputLines: string[] = []; function generateCSS(block: { selector: string, declarations: string[], children: any[] }, parentSelectors: string[] = ['']): void { let currentSelectors: string[] = []; if (block.selector) { let selectorParts = block.selector.split(',').map(s => s.trim()); for (let parentSelector of parentSelectors) { for (let part of selectorParts) { if (part.includes('&')) { currentSelectors.push(part.replace(/&/g, parentSelector)); } else { currentSelectors.push((parentSelector + ' ' + part).trim()); } } } } else { // If there's no selector, inherit the parent selectors currentSelectors = parentSelectors; } if (block.declarations.length > 0) { if (currentSelectors.length > 0) { for (const selector of currentSelectors) { outputLines.push(`${selector} {`); outputLines.push(...block.declarations.map((decl: string) => ' ' + decl)); outputLines.push('}'); } } else { // Top-level declarations (e.g., @import) outputLines.push(...block.declarations); } } // Process children blocks for (const child of block.children) { generateCSS(child, currentSelectors); } } generateCSS(rootBlock); // Combine the output lines into a single string return outputLines.join('\n'); } static loadFromFile(file: string): Promise<string> { if (!file.endsWith('.xcss')) { throw new Error('File must have a .xcss extension'); } if (!fs.existsSync(file)) { throw new Error(`File '${file}' does not exist`); } return new Promise((resolve, reject) => { fs.readFile(file, 'utf8', (err, data) => { if (err) { reject(err); } else { const cssOutput = XCSS.compile(data); resolve(cssOutput); } }); }); } static saveToFile(code: string, output: string) { if (!output.endsWith('.css')) { throw new Error('Output file must have a .css extension'); } fs.writeFileSync(output, code); }}
export default XCSS;
- Assistant
The issue with the
XCSS.saveToFilefunction is that it expects the first parameter to be the code string, but in practical usage, you would want to provide an input file (the.xcssfile) and an output file (the.cssfile). The current implementation doesn't read from an input file or compile the code before saving it.Here's how you can fix the
saveToFilefunction:-
Change the Function Signature: Update the function to accept an input file path and an output file path, rather than a code string and output path.
-
Read and Compile the Input File: Use the
loadFromFilemethod to read and compile the.xcssfile. -
Write the Compiled CSS to the Output File: Write the compiled CSS code to the specified output file.
-
Handle Asynchronous Operations: Since file operations are asynchronous, use
async/awaitto handle the promises cleanly.
Here's the corrected and improved
saveToFilefunction:static async saveToFile(inputFile: string, outputFile: string): Promise<void> { // Validate file extensions if (!inputFile.endsWith('.xcss')) { throw new Error('Input file must have a .xcss extension'); } if (!outputFile.endsWith('.css')) { throw new Error('Output file must have a .css extension'); } // Check if the input file exists if (!fs.existsSync(inputFile)) { throw new Error(`Input file '${inputFile}' does not exist`); } try { // Read and compile the input file const cssOutput = await XCSS.loadFromFile(inputFile); // Write the compiled CSS to the output file fs.writeFileSync(outputFile, cssOutput); } catch (err) { throw new Error(`Error processing files: ${err.message}`); } }Explanation of Changes:
- Updated Parameters: The function now takes
inputFileandoutputFileas parameters. - Added File Existence Check: Ensures the input file exists before proceeding.
- Used
loadFromFileMethod: Reads and compiles the.xcssfile using the existing method. - Used
fs.writeFileSync: Writes the compiled CSS synchronously for simplicity. - Async Function: Marked the function as
asyncto useawaitwith theloadFromFilemethod.
Full Corrected Code:
import fs from 'fs'; class XCSS { static compile(code: string): string { // ... [Your existing compile method code remains unchanged] } static loadFromFile(file: string): Promise<string> { // ... [Your existing loadFromFile method code remains unchanged] } static async saveToFile(inputFile: string, outputFile: string): Promise<void> { // Validate file extensions if (!inputFile.endsWith('.xcss')) { throw new Error('Input file must have a .xcss extension'); } if (!outputFile.endsWith('.css')) { throw new Error('Output file must have a .css extension'); } // Check if the input file exists if (!fs.existsSync(inputFile)) { throw new Error(`Input file '${inputFile}' does not exist`); } try { // Read and compile the input file const cssOutput = await XCSS.loadFromFile(inputFile); // Write the compiled CSS to the output file fs.writeFileSync(outputFile, cssOutput); } catch (err) { throw new Error(`Error processing files: ${err.message}`); } } } export default XCSS;Usage Example:
(async () => { try { await XCSS.saveToFile('styles.xcss', 'styles.css'); console.log('CSS file generated successfully.'); } catch (err) { console.error(err.message); } })();Notes:
- Error Handling: The function now includes try-catch blocks to provide meaningful error messages.
- Synchronous vs. Asynchronous: While
fs.writeFileSyncis synchronous, it simplifies the code. If you prefer asynchronous file writing, you can replace it withfs.promises.writeFileand adjust the code accordingly. - Consistency: This change makes the
saveToFilemethod consistent with typical usage patterns and aligns it with theloadFromFilemethod.
By making these changes, the
saveToFilefunction now properly reads from an input.xcssfile, compiles it using thecompilemethod, and writes the output to a.cssfile. -