AG-57807 Fix empty user rules editor after update

Author: maximtop

CHANGELOG.md

@@ -97,8 +97,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 - Short-lived duplicated elements on pages when CSS hits counting is enabled.
+- User rules saved with Windows line endings appeared empty in the editor after
+  updating to 5.5 [#3598].
 
 [5.5 patch 1]: https://github.com/AdguardTeam/AdguardBrowserExtension/compare/v5.5.0.6...v5.5.1.0
+[#3598]: https://github.com/AdguardTeam/AdguardBrowserExtension/issues/3598
 
 ## [5.4 patch 2] - 2026-05-14
 

Extension/src/background/api/filters/userrules.ts

@@ -32,6 +32,7 @@ import { notifier } from '../../notifier';
 import { settingsStorage, editorStorage } from '../../storages';
 import { FiltersStoragesAdapter } from '../../storages/filters-adapter';
 import { getZodErrorMessage } from '../../../common/error';
+import { normalizeUserRulesLineEndings } from '../../../common/utils/user-rules';
 import { LineScanner } from '../../utils';
 
 /**
@@ -42,10 +43,13 @@ export class UserRulesApi {
      * Parses data from user rules list.
      * If it's undefined or if it's an initialization after installation - sets
      * empty user rules list.
+     * Existing user rules line endings are normalized to Unix-style line feeds.
      *
      * @param isInstall Is this is an installation initialization or not.
      */
     public static async init(isInstall: boolean): Promise<void> {
+        let userRules: FilterList | undefined;
+
         try {
             // Check if user filter is present in the storage to avoid errors.
             if (!(await FiltersStoragesAdapter.has(AntiBannerFiltersId.UserFilterId))) {
@@ -55,7 +59,7 @@ export class UserRulesApi {
                 );
             } else {
                 // In this case zod will validate the data.
-                await FiltersStoragesAdapter.get(AntiBannerFiltersId.UserFilterId);
+                userRules = await FiltersStoragesAdapter.get(AntiBannerFiltersId.UserFilterId);
             }
         } catch (e) {
             if (!isInstall) {
@@ -66,6 +70,26 @@ export class UserRulesApi {
                 FilterList.createEmpty(),
             );
         }
+
+        if (!userRules) {
+            return;
+        }
+
+        const originalUserRules = userRules.getOriginalContent();
+        const normalizedUserRules = normalizeUserRulesLineEndings(originalUserRules);
+
+        if (normalizedUserRules === originalUserRules) {
+            return;
+        }
+
+        try {
+            await FiltersStoragesAdapter.set(
+                AntiBannerFiltersId.UserFilterId,
+                normalizedUserRules,
+            );
+        } catch (e) {
+            logger.warn('[ext.UserRulesApi.init]: cannot normalize user rules line endings, keeping persisted rules unchanged. Origin error:', getZodErrorMessage(e));
+        }
     }
 
     /**
@@ -221,7 +245,10 @@ export class UserRulesApi {
      * @param rulesText Rule text.
      */
     public static async setUserRules(rulesText: string): Promise<void> {
-        await FiltersStoragesAdapter.set(AntiBannerFiltersId.UserFilterId, rulesText);
+        await FiltersStoragesAdapter.set(
+            AntiBannerFiltersId.UserFilterId,
+            normalizeUserRulesLineEndings(rulesText),
+        );
 
         notifier.notifyListeners(NotifierType.UserFilterUpdated);
     }

Extension/src/common/constants.ts

@@ -246,7 +246,7 @@ export enum FiltersUpdateTime {
 }
 
 export const NEWLINE_CHAR_UNIX = '\n';
-export const NEWLINE_CHAR_REGEX = /\r?\n/;
+export const NEWLINE_CHAR_REGEX = /\r\n|\r|\n/;
 
 export const OPTIONS_PAGE = 'pages/options.html';
 

Extension/src/common/utils/user-rules.ts

@@ -35,6 +35,17 @@ export type MergeImportedRulesResult = {
     addedCount: number;
 };
 
+/**
+ * Normalizes user rules line endings to Unix-style line feeds.
+ *
+ * @param rulesText User rules text.
+ *
+ * @returns User rules text with normalized line endings.
+ */
+export function normalizeUserRulesLineEndings(rulesText: string): string {
+    return rulesText.split(NEWLINE_CHAR_REGEX).join(NEWLINE_CHAR_UNIX);
+}
+
 /**
  * Parses raw imported rule text and merges only the genuinely-new, non-blank
  * rules into the existing rules string.

Extension/src/pages/common/components/Editor/editor-handle.ts

@@ -139,9 +139,15 @@ export const createEditorHandle = (
      * @param value The new content to set.
      */
     setValue(value: string) {
+        const changes = view.state.changes({
+            from: 0,
+            to: view.state.doc.length,
+            insert: value,
+        });
+
         view.dispatch({
-            changes: { from: 0, to: view.state.doc.length, insert: value },
-            selection: { anchor: value.length },
+            changes,
+            selection: { anchor: changes.newLength },
             annotations: isolateHistory.of('full'),
         });
     },

tests/src/background/api/filters/userrules.test.ts

@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) 2015-2026 Adguard Software Ltd.
+ *
+ * @file
+ * This file is part of AdGuard Browser Extension (https://github.com/AdguardTeam/AdguardBrowserExtension).
+ *
+ * AdGuard Browser Extension is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * AdGuard Browser Extension is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with AdGuard Browser Extension. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { type Storage } from 'webextension-polyfill';
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+    vi,
+} from 'vitest';
+
+import { UserRulesApi } from '../../../../../Extension/src/background/api/filters/userrules';
+import { FiltersStoragesAdapter } from '../../../../../Extension/src/background/storages/filters-adapter';
+import { hybridStorage } from '../../../../../Extension/src/background/storages';
+import { AntiBannerFiltersId } from '../../../../../Extension/src/common/constants';
+import { mockLocalStorage } from '../../../../helpers';
+
+describe('UserRulesApi', () => {
+    let localStorage: Storage.StorageArea;
+
+    beforeEach(() => {
+        localStorage = mockLocalStorage();
+    });
+
+    afterEach(async () => {
+        await localStorage.clear();
+        await hybridStorage.clear();
+    });
+
+    it('normalizes line endings when user rules are saved', async () => {
+        await UserRulesApi.setUserRules('||a.com^\r\n||b.com^\r||c.com^');
+
+        await expect(UserRulesApi.getOriginalUserRules())
+            .resolves.toBe('||a.com^\n||b.com^\n||c.com^');
+    });
+
+    it('normalizes line endings in existing user rules during initialization', async () => {
+        await FiltersStoragesAdapter.set(
+            AntiBannerFiltersId.UserFilterId,
+            '||a.com^\r\n||b.com^',
+        );
+
+        await expect(UserRulesApi.getOriginalUserRules())
+            .resolves.toBe('||a.com^\r\n||b.com^');
+
+        await UserRulesApi.init(false);
+
+        await expect(UserRulesApi.getOriginalUserRules())
+            .resolves.toBe('||a.com^\n||b.com^');
+    });
+
+    it('preserves existing rules when initialization cannot save normalized content', async () => {
+        await FiltersStoragesAdapter.set(
+            AntiBannerFiltersId.UserFilterId,
+            '||a.com^\r\n||b.com^',
+        );
+        const setSpy = vi.spyOn(FiltersStoragesAdapter, 'set')
+            .mockRejectedValueOnce(new Error('Storage write failed'));
+
+        try {
+            await UserRulesApi.init(false);
+
+            await expect(UserRulesApi.getOriginalUserRules())
+                .resolves.toBe('||a.com^\r\n||b.com^');
+        } finally {
+            setSpy.mockRestore();
+        }
+    });
+});

tests/src/common/utils/user-rules.test.ts

@@ -24,7 +24,14 @@ import {
     expect,
 } from 'vitest';
 
-import { mergeImportedRules } from '../../../../Extension/src/common/utils/user-rules';
+import { mergeImportedRules, normalizeUserRulesLineEndings } from '../../../../Extension/src/common/utils/user-rules';
+
+describe('normalizeUserRulesLineEndings', () => {
+    it('normalizes mixed line endings to Unix-style line feeds', () => {
+        expect(normalizeUserRulesLineEndings('||a.com^\r\n||b.com^\r||c.com^\n'))
+            .toBe('||a.com^\n||b.com^\n||c.com^\n');
+    });
+});
 
 describe('mergeImportedRules', () => {
     it('appends only genuinely-new rules and preserves existing order', () => {

tests/src/pages/common/components/Editor/Editor.test.tsx

@@ -33,6 +33,13 @@ import {
     it,
     vi,
 } from 'vitest';
+import {
+    EditorState,
+    type Extension,
+    type TransactionSpec,
+} from '@codemirror/state';
+
+import { initEditor as initRulesEditor } from '@adguard/rules-editor';
 
 import { Editor } from '../../../../../../Extension/src/pages/common/components/Editor/Editor';
 
@@ -74,24 +81,26 @@ describe('Editor component', () => {
         localStorage.clear();
     });
 
-    const createFakeView = () => ({
-        state: {
-            doc: {
-                toString: () => 'fake content',
-                length: 12,
-                lineAt: () => ({ number: 1, from: 0, length: 12 }),
-                lines: 1,
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                line: (_n: number) => ({ from: 0, length: 12 }),
+    const createFakeView = () => {
+        const config = vi.mocked(initRulesEditor).mock.lastCall?.[2] as { extensions?: Extension[] };
+        let state = EditorState.create({
+            doc: 'fake content',
+            extensions: config.extensions,
+        });
+
+        return {
+            get state() {
+                return state;
             },
-            selection: { main: { head: 0 } },
-            readOnly: false,
-        },
-        dispatch: mockDispatch,
-        destroy: mockDestroy,
-        focus: mockFocus,
-        lineWrapping: false,
-    });
+            dispatch: (...specs: TransactionSpec[]) => {
+                mockDispatch(...specs);
+                state = state.update(...specs).state;
+            },
+            destroy: mockDestroy,
+            focus: mockFocus,
+            lineWrapping: false,
+        };
+    };
 
     const renderEditor = (props = {}) => render(React.createElement(Editor as any, {
         name: 'test-editor',
@@ -204,11 +213,7 @@ describe('Editor component', () => {
             resolveInit(createFakeView());
         });
 
-        // Buffered write is replayed onto the view via a dispatch.
-        const replayed = mockDispatch.mock.calls.some(
-            ([tr]) => tr?.changes?.insert === 'content set before ready',
-        );
-        expect(replayed).toBe(true);
+        expect(editorRef.current.getValue()).toBe('content set before ready');
 
         rendered!.unmount();
     });

tests/src/pages/common/components/Editor/editor-handle.test.ts

@@ -70,6 +70,14 @@ describe('createEditorHandle', () => {
         expect(handle.getCursor()).toEqual({ line: 1, ch: 'new content'.length });
     });
 
+    it('loads CRLF content and places the cursor at the normalized document end', () => {
+        const handle = createEditorHandle(view, { wrap, readOnly });
+
+        expect(() => handle.setValue('first line\r\nsecond line')).not.toThrow();
+        expect(handle.getValue()).toBe('first line\nsecond line');
+        expect(handle.getCursor()).toEqual({ line: 2, ch: 'second line'.length });
+    });
+
     it('round-trips the cursor (1-based line, 0-based ch)', () => {
         const handle = createEditorHandle(view, { wrap, readOnly });
         handle.setCursor({ line: 2, ch: 3 });
@@ -142,6 +150,18 @@ describe('createDeferredEditorHandle', () => {
         view.destroy();
     });
 
+    it('replays buffered CRLF content once attached', () => {
+        const deferred = createDeferredEditorHandle();
+        deferred.handle.setValue('first line\r\nsecond line');
+
+        const view = createView();
+
+        expect(() => deferred.attach(view, { wrap, readOnly })).not.toThrow();
+        expect(deferred.handle.getValue()).toBe('first line\nsecond line');
+        expect(deferred.handle.getCursor()).toEqual({ line: 2, ch: 'second line'.length });
+        view.destroy();
+    });
+
     it('replays setValue before setCursor so the cursor is preserved', () => {
         const deferred = createDeferredEditorHandle();
         deferred.handle.setValue('alpha\nbeta');