fixes

Author: princemaple

fold_angular_imports.py

@@ -21,21 +21,19 @@ def on_load_async(self, view):
         if self.should_auto_fold(view):
             self.fold_angular_imports(view)
 
-    def on_activated_async(self, view):
-        """Called when a view gains input focus"""
-        # Only fold if not already processed and auto-folding is enabled
-        if self.should_auto_fold(view) and not view.settings().get("angular_imports_folded", False):
-            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)
 
@@ -57,15 +55,15 @@ def fold_angular_imports(self, view):
                 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)
 
@@ -91,7 +89,7 @@ def find_imports_array(self, view, content):
 
         # 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
@@ -107,7 +105,7 @@ def find_imports_array(self, view, content):
                     # 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)
@@ -119,135 +117,153 @@ def find_imports_array(self, view, content):
 
     def find_import_chunks(self, view, content):
         """Find chunks of import statements and return regions for folding"""
-        lines = content.split('\n')
+        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('/*'))
-            
+            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('/*'))
-            
+            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)
-            
+            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('*'))
-                
+                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)
+                        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)
+                        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)
+            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')
-        
+        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:
+            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:
+                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:
+                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
-        
+        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
 
 
@@ -260,21 +276,21 @@ def run(self, edit):
 
         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 self.is_typescript_file()
-    
+        return bool(self.is_typescript_file())
+
     def is_typescript_file(self):
         file_name = self.view.file_name()
-        return file_name and file_name.endswith(".ts")
+        return bool(file_name and file_name.endswith(".ts"))
 
 
 class FoldImportArraysCommand(sublime_plugin.TextCommand):
@@ -286,16 +302,16 @@ def run(self, edit):
 
         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 self.is_angular_file()
-    
+        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"):
@@ -314,7 +330,7 @@ def run(self, edit):
 
     def is_enabled(self):
         file_name = self.view.file_name()
-        return file_name and file_name.endswith(".ts")
+        return bool(file_name and file_name.endswith(".ts"))
 
 
 class UnfoldImportStatementsCommand(sublime_plugin.TextCommand):
@@ -325,7 +341,7 @@ def run(self, edit):
         # 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()))
@@ -336,7 +352,7 @@ def run(self, edit):
 
     def is_enabled(self):
         file_name = self.view.file_name()
-        return file_name and file_name.endswith(".ts")
+        return bool(file_name and file_name.endswith(".ts"))
 
 
 class UnfoldImportArraysCommand(sublime_plugin.TextCommand):
@@ -346,7 +362,7 @@ 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()))
@@ -376,4 +392,4 @@ def run(self, edit):
 
     def is_enabled(self):
         file_name = self.view.file_name()
-        return file_name and file_name.endswith(".ts")
+        return bool(file_name and file_name.endswith(".ts"))