fold_angular_imports.py

import sublime
import sublime_plugin
import re


class FoldAngularImportsListener(sublime_plugin.EventListener):
    """
    Sublime Text plugin that optionally folds imports in Angular TypeScript files.

    When auto-folding is enabled and opening a .ts file that contains @Component or @Directive decorator,
    it will:
    1. Find and fold the imports array in the decorator to keep the file more readable
    2. Find and fold consecutive chunks of import statements at the top of the file

    Import chunks are automatically detected and grouped (e.g., Angular imports,
    library imports, local project imports) based on blank lines or comment separators.
    """

    def on_load_async(self, view):
        """Called when a file is loaded"""
        if self.should_auto_fold(view):
            self.fold_angular_imports(view)

    # Removed on_activated_async to prevent auto-folding when view regains focus
    # This was causing issues where manually unfolding would immediately re-fold
    # Auto-folding now only happens on file load via on_load_async

    def should_auto_fold(self, view):
        """Check if auto-folding should be enabled for this view"""
        # Check package settings for auto-folding preference
        settings = sublime.load_settings("NgxHTML.sublime-settings")
        auto_fold_enabled = settings.get("auto_fold_angular_imports", False)

        if not auto_fold_enabled:
            return False

        # Check if it's a TypeScript file
        return self.is_typescript_file(view)

    def fold_angular_imports(self, view):
        """Main method to detect Angular files and fold imports array"""
        # Check if it's a TypeScript file
        if not self.is_typescript_file(view):
            return

        # Get the entire file content
        file_content = view.substr(sublime.Region(0, view.size()))

        folded_something = False

        # Find and fold the imports array (only in Angular files)
        if self.is_angular_file(file_content):
            imports_region = self.find_imports_array(view, file_content)
            if imports_region:
                view.fold(imports_region)
                view.settings().set("import_arrays_folded", True)
                folded_something = True

        # Find and fold import statement chunks at the top (for all TypeScript files)
        import_chunks = self.find_import_chunks(view, file_content)
        if import_chunks:
            for chunk in import_chunks:
                view.fold(chunk)
            view.settings().set("import_statements_folded", True)
            folded_something = True

        if folded_something:
            view.settings().set("angular_imports_folded", True)

    def is_typescript_file(self, view):
        """Check if the current file is a TypeScript file"""
        file_name = view.file_name()
        if not file_name:
            return False
        return file_name.endswith(".ts")

    def is_angular_file(self, content):
        """Check if the file contains @Component or @Directive decorators"""
        return bool(re.search(r"@(Component|Directive)\s*\(", content))

    def find_imports_array(self, view, content):
        """Find the imports array and return its region for folding"""
        # Pattern to match the imports array line
        imports_pattern = r"(\s+imports:\s*\[)"

        match = re.search(imports_pattern, content)
        if not match:
            return None

        # Get the position of the opening bracket
        bracket_start = match.end() - 1  # Position of the opening bracket '['

        # Find the matching closing bracket
        bracket_count = 0
        pos = bracket_start  # Start from the opening bracket

        while pos < len(content):
            char = content[pos]
            if char == "[":
                bracket_count += 1
            elif char == "]":
                bracket_count -= 1
                if bracket_count == 0:
                    # Found the matching closing bracket
                    # Fold from after the opening bracket to before the closing bracket
                    fold_start = bracket_start + 1  # After the '['
                    fold_end = pos  # Before the ']'

                    # Only fold if there's content between brackets
                    if fold_end > fold_start:
                        return sublime.Region(fold_start, fold_end)
                    else:
                        return None
            pos += 1

        return None

    def find_import_chunks(self, view, content):
        """Find chunks of import statements and return regions for folding"""
        lines = content.split("\n")
        chunks = []
        current_chunk_start = None
        current_chunk_end = None
        in_multiline_import = False

        i = 0
        while i < len(lines):
            line = lines[i]
            stripped_line = line.strip()

            # Check if this is a single-line import
            is_single_line_import = (
                stripped_line.startswith("import ")
                and " from " in stripped_line
                and not stripped_line.startswith("//")
                and not stripped_line.startswith("/*")
            )

            # Check if this starts a multi-line import
            is_multiline_import_start = (
                stripped_line.startswith("import ")
                and " from " not in stripped_line
                and "{" in stripped_line
                and not stripped_line.startswith("//")
                and not stripped_line.startswith("/*")
            )

            # Check if we're continuing a multi-line import
            is_multiline_import_continuation = in_multiline_import

            # Check if this ends a multi-line import
            is_multiline_import_end = in_multiline_import and " from " in stripped_line

            is_import_line = (
                is_single_line_import
                or is_multiline_import_start
                or is_multiline_import_continuation
                or is_multiline_import_end
            )

            # Update multiline import state
            if is_multiline_import_start:
                in_multiline_import = True
            elif is_multiline_import_end:
                in_multiline_import = False

            if is_import_line:
                if current_chunk_start is None:
                    # Start of a new chunk
                    current_chunk_start = i
                current_chunk_end = i
            else:
                # Check if this is a blank line or comment that could separate chunks
                is_separator = (
                    stripped_line == ""
                    or stripped_line.startswith("//")
                    or stripped_line.startswith("/*")
                    or stripped_line.startswith("*")
                )

                if current_chunk_start is not None and not is_separator:
                    # End of current chunk - create fold if chunk has multiple lines
                    if current_chunk_end > current_chunk_start:
                        chunk_region = self.lines_to_region(
                            view, content, current_chunk_start, current_chunk_end
                        )
                        if chunk_region:
                            chunks.append(chunk_region)
                    current_chunk_start = None
                    current_chunk_end = None

                    # Stop if we hit substantial non-import content (not just separators)
                    if not is_separator:
                        break
                elif current_chunk_start is not None and is_separator:
                    # We're in a chunk and hit a separator - end current chunk and prepare for next
                    if current_chunk_end > current_chunk_start:
                        chunk_region = self.lines_to_region(
                            view, content, current_chunk_start, current_chunk_end
                        )
                        if chunk_region:
                            chunks.append(chunk_region)
                    current_chunk_start = None
                    current_chunk_end = None

            i += 1

        # Handle case where file ends with imports
        if current_chunk_start is not None and current_chunk_end > current_chunk_start:
            chunk_region = self.lines_to_region(
                view, content, current_chunk_start, current_chunk_end
            )
            if chunk_region:
                chunks.append(chunk_region)

        return chunks

    def lines_to_region(self, view, content, start_line, end_line):
        """Convert line numbers to a Sublime Text region, leaving first import visible"""
        lines = content.split("\n")

        # Only fold if there's more than one import (need at least 2 lines to fold)
        if end_line <= start_line:
            return None

        # Find where the first import statement ends
        first_import_end = start_line
        in_multiline_import = False

        for i in range(start_line, end_line + 1):
            line = lines[i].strip()

            # Check if this starts a multi-line import
            if line.startswith("import ") and "{" in line and " from " not in line:
                in_multiline_import = True

            # If we're in a multi-line import, keep going until we find the 'from' line
            if in_multiline_import:
                if " from " in line:
                    first_import_end = i
                    break
            else:
                # Single line import - this line is the complete import
                if line.startswith("import ") and " from " in line:
                    first_import_end = i
                    break

        # Start folding from the line after the first complete import
        fold_start_line = first_import_end + 1

        # Make sure we have something to fold
        if fold_start_line > end_line:
            return None

        # Calculate character positions
        fold_start_pos = sum(
            len(lines[i]) + 1 for i in range(fold_start_line)
        )  # +1 for newline
        fold_end_pos = (
            sum(len(lines[i]) + 1 for i in range(end_line + 1)) - 1
        )  # -1 to not include final newline

        # Only fold if there's actual content
        if fold_end_pos > fold_start_pos:
            return sublime.Region(fold_start_pos, fold_end_pos)

        return None


class FoldImportStatementsCommand(sublime_plugin.TextCommand):
    """Command to manually fold import statements only"""

    def run(self, edit):
        if not self.is_typescript_file():
            return

        content = self.view.substr(sublime.Region(0, self.view.size()))
        listener = FoldAngularImportsListener()

        # Find and fold import statement chunks only
        import_chunks = listener.find_import_chunks(self.view, content)
        for chunk in import_chunks:
            self.view.fold(chunk)

        if import_chunks:
            self.view.settings().set("import_statements_folded", True)

    def is_enabled(self):
        return bool(self.is_typescript_file())

    def is_typescript_file(self):
        file_name = self.view.file_name()
        return bool(file_name and file_name.endswith(".ts"))


class FoldImportArraysCommand(sublime_plugin.TextCommand):
    """Command to manually fold imports arrays in Angular decorators only"""

    def run(self, edit):
        if not self.is_angular_file():
            return

        content = self.view.substr(sublime.Region(0, self.view.size()))
        listener = FoldAngularImportsListener()

        # Find and fold the imports array only
        imports_region = listener.find_imports_array(self.view, content)
        if imports_region:
            self.view.fold(imports_region)
            self.view.settings().set("import_arrays_folded", True)

    def is_enabled(self):
        return bool(self.is_angular_file())

    def is_angular_file(self):
        file_name = self.view.file_name()
        if not file_name or not file_name.endswith(".ts"):
            return False

        content = self.view.substr(sublime.Region(0, self.view.size()))
        return bool(re.search(r"@(Component|Directive)\s*\(", content))


class FoldAllImportsCommand(sublime_plugin.TextCommand):
    """Command to manually fold both import statements and import arrays"""

    def run(self, edit):
        listener = FoldAngularImportsListener()
        listener.fold_angular_imports(self.view)

    def is_enabled(self):
        file_name = self.view.file_name()
        return bool(file_name and file_name.endswith(".ts"))


class UnfoldImportStatementsCommand(sublime_plugin.TextCommand):
    """Command to unfold import statements only"""

    def run(self, edit):
        # Unfold all regions, but this is a limitation - Sublime doesn't allow selective unfolding
        # In practice, this will unfold everything, but we'll track the state
        self.view.unfold(sublime.Region(0, self.view.size()))
        self.view.settings().set("import_statements_folded", False)

        # Re-fold import arrays if they were previously folded
        if self.view.settings().get("import_arrays_folded", False):
            content = self.view.substr(sublime.Region(0, self.view.size()))
            listener = FoldAngularImportsListener()
            imports_region = listener.find_imports_array(self.view, content)
            if imports_region:
                self.view.fold(imports_region)

    def is_enabled(self):
        file_name = self.view.file_name()
        return bool(file_name and file_name.endswith(".ts"))


class UnfoldImportArraysCommand(sublime_plugin.TextCommand):
    """Command to unfold import arrays only"""

    def run(self, edit):
        # Unfold all regions, but this is a limitation - Sublime doesn't allow selective unfolding
        self.view.unfold(sublime.Region(0, self.view.size()))
        self.view.settings().set("import_arrays_folded", False)

        # Re-fold import statements if they were previously folded
        if self.view.settings().get("import_statements_folded", False):
            content = self.view.substr(sublime.Region(0, self.view.size()))
            listener = FoldAngularImportsListener()
            import_chunks = listener.find_import_chunks(self.view, content)
            for chunk in import_chunks:
                self.view.fold(chunk)

    def is_enabled(self):
        file_name = self.view.file_name()
        if not file_name or not file_name.endswith(".ts"):
            return False

        content = self.view.substr(sublime.Region(0, self.view.size()))
        return bool(re.search(r"@(Component|Directive)\s*\(", content))


class UnfoldAllImportsCommand(sublime_plugin.TextCommand):
    """Command to unfold all imports (both statements and arrays)"""

    def run(self, edit):
        # Unfold all regions in the current view
        self.view.unfold(sublime.Region(0, self.view.size()))
        self.view.settings().set("angular_imports_folded", False)
        self.view.settings().set("import_statements_folded", False)
        self.view.settings().set("import_arrays_folded", False)

    def is_enabled(self):
        file_name = self.view.file_name()
        return bool(file_name and file_name.endswith(".ts"))