@public-ui/kolibri-cli 4.0.0-alpha.0 → 4.0.0-alpha.2

package/dist/migrate/runner/tasks/common/RefactorPropertyIconAlign.js

@@ -9,6 +9,7 @@ const types_1 = require("../../../../types");
 const reuse_1 = require("../../../shares/reuse");
 const abstract_task_1 = require("../../abstract-task");
 class RefactorPropertyIconAlign extends abstract_task_1.AbstractTask {
+    tag;
     constructor(tag) {
         super(`refactor-property-icon-align`, `Refactor property "_icon-align" - integrate in "_icons" property`, types_1.MARKUP_EXTENSIONS, '^2'); //fixme revert version
         this.tag = tag;
@@ -53,11 +54,11 @@ class RefactorPropertyIconAlign extends abstract_task_1.AbstractTask {
             const iconAlignMatches = componentTag.match(iconAlignRegex);
             const iconsMatches = componentTag.match(iconsRegex);
             // Make sure icons and iconAlign are valid
-            if ((iconAlignMatches === null || iconAlignMatches === void 0 ? void 0 : iconAlignMatches[1]) && (iconsMatches === null || iconsMatches === void 0 ? void 0 : iconsMatches[1])) {
+            if (iconAlignMatches?.[1] && iconsMatches?.[1]) {
                 // Replace icons and iconAlign with one joined object
                 const newIcons = isComponent
-                    ? `_icons={{ '${iconAlignMatches === null || iconAlignMatches === void 0 ? void 0 : iconAlignMatches[1]}': '${iconsMatches === null || iconsMatches === void 0 ? void 0 : iconsMatches[1]}' }}`
-                    : `_icons="{ '${iconAlignMatches === null || iconAlignMatches === void 0 ? void 0 : iconAlignMatches[1]}': '${iconsMatches === null || iconsMatches === void 0 ? void 0 : iconsMatches[1]}' }"`;
+                    ? `_icons={{ '${iconAlignMatches?.[1]}': '${iconsMatches?.[1]}' }}`
+                    : `_icons="{ '${iconAlignMatches?.[1]}': '${iconsMatches?.[1]}' }"`;
                 return componentTag.replace(iconAlignRegex, '').replace(iconsRegex, newIcons);
             }
             return componentTag;

package/dist/migrate/runner/tasks/common/RefactorPropertyLabelReplaceFalse.js

@@ -9,10 +9,10 @@ const types_1 = require("../../../../types");
 const reuse_1 = require("../../../shares/reuse");
 const abstract_task_1 = require("../../abstract-task");
 class RefactorPropertyLabelReplaceFalse extends abstract_task_1.AbstractTask {
+    componentRegExp = /_label={false}/g;
+    customElementRegExp = /_label="false"/g;
     constructor() {
         super(`refactor-property-label-replace-false`, `Refactor property "_label" - replace "false" with ""`, types_1.MARKUP_EXTENSIONS, '>=1.6 <=1.7');
-        this.componentRegExp = /_label={false}/g;
-        this.customElementRegExp = /_label="false"/g;
     }
     static getInstance() {
         const identifier = `refact-property-label-replace-false`;

package/dist/migrate/runner/tasks/common/RemoveMsgPropsTask.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveMsgPropsTask = void 0;
+const fs_1 = __importDefault(require("fs"));
+const types_1 = require("../../../../types");
+const reuse_1 = require("../../../shares/reuse");
+const abstract_task_1 = require("../../abstract-task");
+class RemoveMsgPropsTask extends abstract_task_1.AbstractTask {
+    constructor(identifier, versionRange) {
+        super(identifier, 'Remove _label and _variant from _msg', types_1.MARKUP_EXTENSIONS, versionRange);
+    }
+    static getInstance(versionRange) {
+        const identifier = 'remove-msg-props';
+        if (!this.instances.has(identifier)) {
+            this.instances.set(identifier, new RemoveMsgPropsTask(identifier, versionRange));
+        }
+        return this.instances.get(identifier);
+    }
+    run(baseDir) {
+        (0, reuse_1.filterFilesByExt)(baseDir, types_1.MARKUP_EXTENSIONS).forEach((file) => {
+            const content = fs_1.default.readFileSync(file, 'utf8');
+            let newContent = content;
+            newContent = newContent.replace(/_msg=\{\{([\s\S]*?)\}\}/g, (_match, body) => {
+                const updated = String(body)
+                    .replace(/,?\s*_label:\s*[^,}]+/g, '')
+                    .replace(/,?\s*_variant:\s*[^,}]+/g, '')
+                    .replace(/,\s*}/g, ' }')
+                    .replace(/\{\s*,/g, '{ ');
+                return `_msg={{${updated}}}`;
+            });
+            newContent = newContent.replace(/_msg=('([^']*)'|"([^"]*)")/g, (match, _p0, single, dbl) => {
+                const quote = single !== undefined ? "'" : '"';
+                const json = single ?? dbl;
+                try {
+                    const obj = JSON.parse(json);
+                    delete obj._label;
+                    delete obj._variant;
+                    return `_msg=${quote}${JSON.stringify(obj)}${quote}`;
+                }
+                catch {
+                    return match;
+                }
+            });
+            if (content !== newContent) {
+                fs_1.default.writeFileSync(file, newContent);
+                reuse_1.MODIFIED_FILES.add(file);
+            }
+        });
+    }
+}
+exports.RemoveMsgPropsTask = RemoveMsgPropsTask;

package/dist/migrate/runner/tasks/common/RemovePropertyNameTask.js

@@ -10,6 +10,12 @@ const reuse_1 = require("../../../shares/reuse");
 const GenericRenamePropertyTask_1 = require("./GenericRenamePropertyTask");
 const DATA_REMOVED_REGEXP = /data-removed-/g;
 class RemovePropertyNameTask extends GenericRenamePropertyTask_1.GenericRenamePropertyTask {
+    componentRegExpBoolean;
+    componentRegExpCurlyBrackets;
+    componentRegExpQuotationMarks;
+    customElementRegExpBoolean;
+    customElementRegExpCurlyBrackets;
+    customElementRegExpQuotationMarks;
     constructor(identifier, tag, property, versionRange, dependentTasks, options) {
         super(identifier, `Remove property "${property}" of "${tag}" component`, tag, property, `data-removed-${property}`, versionRange, dependentTasks, options);
         if (!reuse_1.isTagKebabCaseRegExp.test(tag)) {

package/dist/migrate/runner/tasks/common/RenamePropertyNameTask.js

@@ -4,10 +4,9 @@ exports.RenamePropertyNameTask = void 0;
 const GenericRenamePropertyTask_1 = require("./GenericRenamePropertyTask");
 class RenamePropertyNameTask extends GenericRenamePropertyTask_1.GenericRenamePropertyTask {
     static getInstance(tag, oldProperty, newProperty, versionRange, dependentTasks = [], options = {}) {
-        var _a;
         const identifier = `${tag}-rename-property-${oldProperty}-to-${newProperty}`;
         if (!this.instances.has(identifier)) {
-            (_a = this.instances) === null || _a === void 0 ? void 0 : _a.set(identifier, new RenamePropertyNameTask(identifier, `Rename property "${oldProperty}" to "${newProperty}" of "${tag}" component`, tag, oldProperty, newProperty, versionRange, dependentTasks, options));
+            this.instances?.set(identifier, new RenamePropertyNameTask(identifier, `Rename property "${oldProperty}" to "${newProperty}" of "${tag}" component`, tag, oldProperty, newProperty, versionRange, dependentTasks, options));
         }
         return this.instances.get(identifier);
     }

package/dist/migrate/runner/tasks/common/RenameTagNameTask.js

@@ -4,10 +4,9 @@ exports.RenameTagNameTask = void 0;
 const GenericRenameTagNameTask_1 = require("./GenericRenameTagNameTask");
 class RenameTagNameTask extends GenericRenameTagNameTask_1.GenericRenameTagNameTask {
     static getInstance(oldTagName, newTagName, versionRange, dependentTasks = [], options = {}) {
-        var _a;
         const identifier = `rename-tag-name-${oldTagName}-to-${newTagName}`;
         if (!this.instances.has(identifier)) {
-            (_a = this.instances) === null || _a === void 0 ? void 0 : _a.set(identifier, new RenameTagNameTask(identifier, `Rename tag name "${oldTagName}" to "${newTagName}" component`, oldTagName, newTagName, versionRange, dependentTasks, options));
+            this.instances?.set(identifier, new RenameTagNameTask(identifier, `Rename tag name "${oldTagName}" to "${newTagName}" component`, oldTagName, newTagName, versionRange, dependentTasks, options));
         }
         return this.instances.get(identifier);
     }

package/dist/migrate/runner/tasks/common/ScssAddSelectorTask.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScssAddSelectorTask = void 0;
+const fs_1 = __importDefault(require("fs"));
+const types_1 = require("../../../../types");
+const reuse_1 = require("../../../shares/reuse");
+const abstract_task_1 = require("../../abstract-task");
+/**
+ * Simple, fast hash function for string identifier generation.
+ * Based on djb2 algorithm - much faster than cryptographic hashes for non-security purposes.
+ * @param {string} str String to hash
+ * @returns {string} Hexadecimal hash string
+ */
+function simpleHash(str) {
+    let hash = 5381;
+    for (let i = 0; i < str.length; i++) {
+        hash = (hash << 5) + hash + str.charCodeAt(i);
+    }
+    return (hash >>> 0).toString(16).substring(0, 8);
+}
+/**
+ * Escapes special characters for use in a regular expression.
+ * @param {string} str String to escape
+ * @returns {string} Escaped string
+ */
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Analyzes the content to determine formatting preferences
+ * @param {string} content The CSS content to analyze
+ * @returns {object} Formatting preferences object
+ */
+function analyzeFormatting(content) {
+    const lines = content.split('\n');
+    // Detect indentation
+    let tabCount = 0;
+    let spaceCount = 0;
+    const indentSizes = [];
+    for (const line of lines) {
+        if (line.trim() === '')
+            continue;
+        const leadingWhitespace = line.match(/^(\s*)/)?.[1] || '';
+        if (leadingWhitespace.includes('\t')) {
+            tabCount++;
+        }
+        else if (leadingWhitespace.length > 0) {
+            spaceCount++;
+            indentSizes.push(leadingWhitespace.length);
+        }
+    }
+    const usesTabs = tabCount > spaceCount;
+    const averageSpaceIndent = indentSizes.length > 0 ? Math.round(indentSizes.reduce((sum, size) => sum + size, 0) / indentSizes.length) : 2;
+    // Detect brace formatting patterns
+    let newlineBeforeOpenBrace = false;
+    let newlineAfterOpenBrace = true; // Default to true for readability
+    let newlineBeforeCloseBrace = true; // Default to true for readability
+    let newlineAfterCloseBrace = true; // Default to true for separation
+    // Look for existing CSS rules to determine formatting style
+    const cssRulePattern = /[^{]*\{[^}]*\}/g;
+    const matches = content.match(cssRulePattern);
+    if (matches && matches.length > 0) {
+        let beforeOpenCount = 0;
+        let afterOpenCount = 0;
+        let beforeCloseCount = 0;
+        let afterCloseCount = 0;
+        for (const match of matches) {
+            // Check for newline before opening brace
+            if (/\n\s*\{/.test(match))
+                beforeOpenCount++;
+            // Check for newline after opening brace
+            if (/\{\s*\n/.test(match))
+                afterOpenCount++;
+            // Check for newline before closing brace
+            if (/\n\s*\}/.test(match))
+                beforeCloseCount++;
+            // Check for newline after closing brace (look at the context)
+            if (/\}\s*\n/.test(match))
+                afterCloseCount++;
+        }
+        // Use majority rule for formatting decisions
+        const totalMatches = matches.length;
+        newlineBeforeOpenBrace = beforeOpenCount > totalMatches / 2;
+        newlineAfterOpenBrace = afterOpenCount > totalMatches / 2;
+        newlineBeforeCloseBrace = beforeCloseCount > totalMatches / 2;
+        newlineAfterCloseBrace = afterCloseCount > totalMatches / 2;
+    }
+    return {
+        indentChar: usesTabs ? '\t' : ' ',
+        indentSize: usesTabs ? 1 : averageSpaceIndent,
+        newlineBeforeOpenBrace,
+        newlineAfterOpenBrace,
+        newlineBeforeCloseBrace,
+        newlineAfterCloseBrace,
+    };
+}
+/**
+ * Formats a CSS rule according to the detected formatting style
+ * @param {string} selector The CSS selector
+ * @param {string} rules The CSS rules
+ * @param {object} formatting The formatting preferences
+ * @param {string} formatting.indentChar The character used for indentation (tab or space)
+ * @param {number} formatting.indentSize The number of indent characters per level
+ * @param {boolean} formatting.newlineBeforeOpenBrace Whether to add newline before opening brace
+ * @param {boolean} formatting.newlineAfterOpenBrace Whether to add newline after opening brace
+ * @param {boolean} formatting.newlineBeforeCloseBrace Whether to add newline before closing brace
+ * @param {boolean} formatting.newlineAfterCloseBrace Whether to add newline after closing brace
+ * @returns {string} The formatted CSS rule
+ */
+function formatCssRule(selector, rules, formatting) {
+    const indent = formatting.indentChar.repeat(formatting.indentSize);
+    // Ensure rules are properly indented and trimmed
+    const formattedRules = rules
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .map((line) => indent + line)
+        .join('\n');
+    let result = '';
+    // Add selector
+    result += selector;
+    // Add space or newline before opening brace
+    if (formatting.newlineBeforeOpenBrace) {
+        result += '\n';
+    }
+    else {
+        result += ' ';
+    }
+    // Add opening brace
+    result += '{';
+    // Add newline after opening brace if needed
+    if (formatting.newlineAfterOpenBrace) {
+        result += '\n';
+    }
+    // Add rules
+    if (formattedRules.trim()) {
+        if (!formatting.newlineAfterOpenBrace) {
+            result += ' ';
+        }
+        result += formattedRules;
+        if (!formatting.newlineBeforeCloseBrace) {
+            result += ' ';
+        }
+    }
+    // Add newline before closing brace if needed
+    if (formatting.newlineBeforeCloseBrace && formattedRules.trim()) {
+        result += '\n';
+    }
+    // Add closing brace
+    result += '}';
+    // Add newline after closing brace if needed
+    if (formatting.newlineAfterCloseBrace) {
+        result += '\n';
+    }
+    return result;
+}
+class ScssAddSelectorTask extends abstract_task_1.AbstractTask {
+    selector;
+    rules;
+    regExp;
+    constructor(identifier, selector, rules, versionRange, dependentTasks = [], options = {}) {
+        super(identifier, `Add selector "${selector}"`, types_1.SCSS_FILE_EXTENSIONS, versionRange, dependentTasks, options);
+        this.selector = selector;
+        this.rules = rules;
+        if (!selector.startsWith('.')) {
+            throw (0, reuse_1.logAndCreateError)(`Selector "${selector}" must start with a dot.`);
+        }
+        this.regExp = new RegExp(escapeRegExp(selector) + '\\s*{');
+    }
+    static getInstance(selector, rules, versionRange, dependentTasks = [], options = {}) {
+        // Include rules in identifier to ensure unique instances for different rule sets
+        // Use simple hash to create shorter, more predictable identifiers
+        const rulesHash = simpleHash(rules);
+        const identifier = `add-selector-${selector}-${rulesHash}`;
+        if (!this.instances.has(identifier)) {
+            this.instances.set(identifier, new ScssAddSelectorTask(identifier, selector, rules, versionRange, dependentTasks, options));
+        }
+        return this.instances.get(identifier);
+    }
+    run(baseDir) {
+        (0, reuse_1.filterFilesByExt)(baseDir, types_1.SCSS_FILE_EXTENSIONS).forEach((file) => {
+            let content = fs_1.default.readFileSync(file, 'utf8');
+            if (!this.regExp.test(content)) {
+                const formatting = analyzeFormatting(content);
+                const newRule = formatCssRule(this.selector, this.rules, formatting);
+                // Add appropriate spacing before the new rule
+                if (content.trim() && !content.endsWith('\n')) {
+                    content += '\n';
+                }
+                if (content.trim()) {
+                    content += '\n';
+                }
+                content += newRule;
+                reuse_1.MODIFIED_FILES.add(file);
+                fs_1.default.writeFileSync(file, content);
+            }
+        });
+    }
+}
+exports.ScssAddSelectorTask = ScssAddSelectorTask;

package/dist/migrate/runner/tasks/common/ScssRemoveSelectorTask.js

@@ -0,0 +1,275 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScssRemoveSelectorTask = void 0;
+const fs_1 = __importDefault(require("fs"));
+const types_1 = require("../../../../types");
+const reuse_1 = require("../../../shares/reuse");
+const abstract_task_1 = require("../../abstract-task");
+/**
+ * Finds and removes a CSS selector and its complete rule block, handling nested braces correctly.
+ * Also handles comma-separated selector lists.
+ * @param {string} content The CSS content to process
+ * @param {string} selector The selector to remove (must start with a dot)
+ * @returns {string} The content with the selector removed
+ */
+function removeSelectorWithNestedBraces(content, selector) {
+    let result = content;
+    let offset = 0;
+    let currentIndex = 0;
+    while (currentIndex < content.length) {
+        // Find the next opening brace while properly handling strings and comments
+        const ruleStart = findNextRuleBlock(content, currentIndex);
+        if (ruleStart === -1)
+            break;
+        const openBraceIndex = ruleStart.openBraceIndex;
+        const selectorGroup = content.substring(ruleStart.selectorStart, openBraceIndex).trim();
+        // Check if this selector group contains our target selector
+        const selectors = selectorGroup.split(',').map((s) => s.trim());
+        let targetSelectorIndex = -1;
+        // First try exact match (for comma-separated lists)
+        targetSelectorIndex = selectors.findIndex((s) => s === selector);
+        // If no exact match, check if any selector contains our target as a class
+        if (targetSelectorIndex === -1) {
+            targetSelectorIndex = selectors.findIndex((s) => {
+                // Split by spaces to get individual parts of compound selectors
+                const parts = s.split(/\s+/);
+                return parts.includes(selector);
+            });
+        }
+        if (targetSelectorIndex === -1) {
+            // Target selector not found in this group, advance past this rule
+            currentIndex = findMatchingCloseBrace(content, openBraceIndex);
+            if (currentIndex === -1)
+                break;
+            currentIndex++;
+            continue;
+        }
+        // Find the matching closing brace using the existing brace counting logic
+        const closeBraceIndex = findMatchingCloseBrace(content, openBraceIndex);
+        if (closeBraceIndex === -1) {
+            // Malformed CSS, skip this rule
+            break;
+        }
+        let replacement;
+        if (selectors.length === 1) {
+            // Only one selector in the list, remove the entire rule block
+            replacement = `/* removed ${selector} */`;
+        }
+        else {
+            // Multiple selectors, remove only the target selector
+            const remainingSelectors = selectors.filter((_, index) => index !== targetSelectorIndex);
+            const ruleContent = content.substring(openBraceIndex, closeBraceIndex + 1);
+            replacement = `${remainingSelectors.join(', ')} ${ruleContent}`;
+        }
+        // Adjust for previous replacements
+        const adjustedStart = ruleStart.selectorStart - offset;
+        const adjustedEnd = closeBraceIndex + 1 - offset;
+        result = result.substring(0, adjustedStart) + replacement + result.substring(adjustedEnd);
+        const originalLength = closeBraceIndex + 1 - ruleStart.selectorStart;
+        offset += originalLength - replacement.length;
+        // Continue searching after this rule
+        currentIndex = closeBraceIndex + 1;
+    }
+    return result;
+}
+/**
+ * Finds the next CSS rule block while properly handling strings and comments.
+ * @param {string} content The CSS content to search
+ * @param {number} startIndex The index to start searching from
+ * @returns {object|number} Object with selectorStart and openBraceIndex, or -1 if no rule found
+ */
+function findNextRuleBlock(content, startIndex) {
+    let currentIndex = startIndex;
+    let inString = false;
+    let stringChar = '';
+    let inComment = false;
+    let inSingleLineComment = false;
+    let potentialSelectorStart = -1;
+    while (currentIndex < content.length) {
+        const char = content[currentIndex];
+        const nextChar = content[currentIndex + 1];
+        // Handle single-line comments
+        if (!inString && !inComment && char === '/' && nextChar === '/') {
+            inSingleLineComment = true;
+            currentIndex += 2;
+            continue;
+        }
+        if (inSingleLineComment) {
+            if (char === '\n' || char === '\r') {
+                inSingleLineComment = false;
+            }
+            currentIndex++;
+            continue;
+        }
+        // Handle multi-line comments
+        if (!inString && !inSingleLineComment && char === '/' && nextChar === '*') {
+            inComment = true;
+            currentIndex += 2;
+            continue;
+        }
+        if (inComment) {
+            if (char === '*' && nextChar === '/') {
+                inComment = false;
+                currentIndex += 2;
+                continue;
+            }
+            currentIndex++;
+            continue;
+        }
+        // Handle strings
+        if (!inComment && !inSingleLineComment && (char === '"' || char === "'")) {
+            if (!inString) {
+                inString = true;
+                stringChar = char;
+            }
+            else if (char === stringChar && content[currentIndex - 1] !== '\\') {
+                inString = false;
+                stringChar = '';
+            }
+        }
+        // Look for rule blocks only when not in strings or comments
+        if (!inString && !inComment && !inSingleLineComment) {
+            if (char === '{') {
+                // Found opening brace, find the start of this selector
+                if (potentialSelectorStart === -1) {
+                    // Find the start of the selector by looking backwards for the previous rule end or start of content
+                    potentialSelectorStart = findSelectorStart(content, currentIndex);
+                }
+                return {
+                    selectorStart: potentialSelectorStart,
+                    openBraceIndex: currentIndex,
+                };
+            }
+            else if (char === '}') {
+                // End of a rule, reset potential selector start
+                potentialSelectorStart = -1;
+            }
+            else if (potentialSelectorStart === -1 && /\S/.test(char)) {
+                // First non-whitespace character, potential start of a selector
+                potentialSelectorStart = currentIndex;
+            }
+        }
+        currentIndex++;
+    }
+    return -1;
+}
+/**
+ * Finds the start of a selector by looking backwards from an opening brace.
+ * @param {string} content The CSS content
+ * @param {number} openBraceIndex The index of the opening brace
+ * @returns {number} The index where the selector starts
+ */
+function findSelectorStart(content, openBraceIndex) {
+    let index = openBraceIndex - 1;
+    // Skip whitespace before the opening brace
+    while (index >= 0 && /\s/.test(content[index])) {
+        index--;
+    }
+    // Find the start of the selector (after previous '}' or at beginning)
+    while (index >= 0) {
+        if (content[index] === '}') {
+            return index + 1;
+        }
+        index--;
+    }
+    return 0; // Start of content
+}
+/**
+ * Finds the matching closing brace for an opening brace, handling nested braces correctly.
+ * @param {string} content The CSS content
+ * @param {number} openBraceIndex The index of the opening brace
+ * @returns {number} The index of the matching closing brace, or -1 if not found
+ */
+function findMatchingCloseBrace(content, openBraceIndex) {
+    let braceCount = 1;
+    let currentIndex = openBraceIndex + 1;
+    let inString = false;
+    let stringChar = '';
+    let inComment = false;
+    let inSingleLineComment = false;
+    while (currentIndex < content.length && braceCount > 0) {
+        const char = content[currentIndex];
+        const nextChar = content[currentIndex + 1];
+        // Handle single-line comments
+        if (!inString && !inComment && char === '/' && nextChar === '/') {
+            inSingleLineComment = true;
+            currentIndex += 2;
+            continue;
+        }
+        if (inSingleLineComment) {
+            if (char === '\n' || char === '\r') {
+                inSingleLineComment = false;
+            }
+            currentIndex++;
+            continue;
+        }
+        // Handle multi-line comments
+        if (!inString && !inSingleLineComment && char === '/' && nextChar === '*') {
+            inComment = true;
+            currentIndex += 2;
+            continue;
+        }
+        if (inComment) {
+            if (char === '*' && nextChar === '/') {
+                inComment = false;
+                currentIndex += 2;
+                continue;
+            }
+            currentIndex++;
+            continue;
+        }
+        // Handle strings
+        if (!inComment && !inSingleLineComment && (char === '"' || char === "'")) {
+            if (!inString) {
+                inString = true;
+                stringChar = char;
+            }
+            else if (char === stringChar && content[currentIndex - 1] !== '\\') {
+                inString = false;
+                stringChar = '';
+            }
+        }
+        // Count braces only when not in strings or comments
+        if (!inString && !inComment && !inSingleLineComment) {
+            if (char === '{') {
+                braceCount++;
+            }
+            else if (char === '}') {
+                braceCount--;
+            }
+        }
+        currentIndex++;
+    }
+    return braceCount === 0 ? currentIndex - 1 : -1;
+}
+class ScssRemoveSelectorTask extends abstract_task_1.AbstractTask {
+    selector;
+    constructor(identifier, selector, versionRange, dependentTasks = [], options = {}) {
+        super(identifier, `Remove selector "${selector}"`, types_1.SCSS_FILE_EXTENSIONS, versionRange, dependentTasks, options);
+        this.selector = selector;
+        if (!selector.startsWith('.')) {
+            throw (0, reuse_1.logAndCreateError)(`Selector "${selector}" must start with a dot.`);
+        }
+    }
+    static getInstance(selector, versionRange, dependentTasks = [], options = {}) {
+        const identifier = `remove-selector-${selector}`;
+        if (!this.instances.has(identifier)) {
+            this.instances.set(identifier, new ScssRemoveSelectorTask(identifier, selector, versionRange, dependentTasks, options));
+        }
+        return this.instances.get(identifier);
+    }
+    run(baseDir) {
+        (0, reuse_1.filterFilesByExt)(baseDir, types_1.SCSS_FILE_EXTENSIONS).forEach((file) => {
+            const content = fs_1.default.readFileSync(file, 'utf8');
+            const newContent = removeSelectorWithNestedBraces(content, this.selector);
+            if (content !== newContent) {
+                reuse_1.MODIFIED_FILES.add(file);
+                fs_1.default.writeFileSync(file, newContent);
+            }
+        });
+    }
+}
+exports.ScssRemoveSelectorTask = ScssRemoveSelectorTask;

package/dist/migrate/runner/tasks/common/ScssRenameBlockTask.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScssRenameBlockTask = void 0;
+const fs_1 = __importDefault(require("fs"));
+const types_1 = require("../../../../types");
+const reuse_1 = require("../../../shares/reuse");
+const abstract_task_1 = require("../../abstract-task");
+class ScssRenameBlockTask extends abstract_task_1.AbstractTask {
+    newBlock;
+    regExp;
+    constructor(identifier, block, newBlock, versionRange, dependentTasks = [], options = {}) {
+        super(identifier, `Rename block selector "${block}" to "${newBlock}"`, types_1.SCSS_FILE_EXTENSIONS, versionRange, dependentTasks, options);
+        this.newBlock = newBlock;
+        if (!reuse_1.isKebabCaseRegExp.test(block)) {
+            throw (0, reuse_1.logAndCreateError)(`Block "${block}" is not in kebab case.`);
+        }
+        if (!reuse_1.isKebabCaseRegExp.test(newBlock)) {
+            throw (0, reuse_1.logAndCreateError)(`Block "${newBlock}" is not in kebab case.`);
+        }
+        this.regExp = new RegExp(`\\.${block}(?=(?:__|--|\\b))`, 'g');
+    }
+    static getInstance(block, newBlock, versionRange, dependentTasks = [], options = {}) {
+        const identifier = `${block}-rename-block-${newBlock}`;
+        if (!this.instances.has(identifier)) {
+            this.instances.set(identifier, new ScssRenameBlockTask(identifier, block, newBlock, versionRange, dependentTasks, options));
+        }
+        return this.instances.get(identifier);
+    }
+    run(baseDir) {
+        (0, reuse_1.filterFilesByExt)(baseDir, types_1.SCSS_FILE_EXTENSIONS).forEach((file) => {
+            const content = fs_1.default.readFileSync(file, 'utf8');
+            const newContent = content.replace(this.regExp, `.${this.newBlock}`);
+            if (content !== newContent) {
+                reuse_1.MODIFIED_FILES.add(file);
+                fs_1.default.writeFileSync(file, newContent);
+            }
+        });
+    }
+}
+exports.ScssRenameBlockTask = ScssRenameBlockTask;