as ViewSettings;
return {
@@ -102,101 +99,136 @@ describe('replacementTransformer', () => {
viewSettings,
userLocale: 'en',
content,
- transformers: ['replacement'],
+ sectionHref,
+ transformers: ['proofread'],
};
};
describe('basic functionality', () => {
test('should return content unchanged when no rules', async () => {
const ctx = createMockContext(undefined, 'Hello world
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
expect(result).toContain('Hello world');
});
test('should return content unchanged when rules array is empty', async () => {
const ctx = createMockContext([], 'Hello world
');
- const result = await replacementTransformer.transform(ctx);
-
+ const result = await proofreadTransformer.transform(ctx);
expect(result).toContain('Hello world');
});
- test('should apply simple string replacement', async () => {
- const rules: ReplacementRule[] = [
+ test('should apply simple string replacement with whole-word matching', async () => {
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'Hello',
replacement: 'Hi',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'Hello world
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
expect(result).toContain('Hi world');
expect(result).not.toContain('Hello');
});
test('should apply multiple simple replacements', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'cat',
replacement: 'dog',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
{
id: '2',
+ scope: 'book',
pattern: 'The',
replacement: 'A',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 2,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'The cat sat
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
expect(result).toContain('A dog sat');
});
test('should replace all occurrences, not just first', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'the',
replacement: 'THE',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'the cat and the dog
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
expect(result).toContain('THE cat and THE dog');
});
+
+ test('should not replace partial word matches with whole-word enabled', async () => {
+ const rules: ProofreadRule[] = [
+ {
+ id: '1',
+ scope: 'book',
+ pattern: 'cat',
+ replacement: 'dog',
+ enabled: true,
+ isRegex: false,
+ caseSensitive: true,
+ order: 1,
+ wholeWord: true,
+ },
+ ];
+ const ctx = createMockContext(rules, 'The cat sat on the category
');
+ const result = await proofreadTransformer.transform(ctx);
+
+ expect(result).toContain('dog');
+ expect(result).toContain('category'); // Should not replace "cat" in "category"
+ });
});
describe('regex functionality', () => {
test('should apply regex replacement', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: '\\d+',
replacement: 'NUMBER',
enabled: true,
isRegex: true,
+ caseSensitive: true,
order: 1,
+ wholeWord: false,
},
];
const ctx = createMockContext(rules, 'I have 5 apples and 10 oranges
');
- const result = await replacementTransformer.transform(ctx);
- expect(result).toContain('NUMBER');
- // Check that numbers in the body content are replaced (not in XML namespace URLs)
+ const result = await proofreadTransformer.transform(ctx);
+
const parser = new DOMParser();
const doc = parser.parseFromString(result, 'text/html');
const bodyText = doc.body?.textContent || '';
@@ -205,587 +237,683 @@ describe('replacementTransformer', () => {
});
test('should handle regex with word boundaries', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: '\\bcat\\b',
replacement: 'dog',
enabled: true,
isRegex: true,
+ caseSensitive: true,
order: 1,
+ wholeWord: false,
},
];
const ctx = createMockContext(rules, 'The cat sat on the category
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
expect(result).toContain('dog');
- expect(result).toContain('category'); // Should not replace "cat" in "category"
+ expect(result).toContain('category');
});
- test('should handle case-insensitive regex when specified', async () => {
- const rules: ReplacementRule[] = [
+ test('should handle case-sensitive regex', async () => {
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'the',
replacement: 'THE',
enabled: true,
isRegex: true,
- order: 1,
caseSensitive: true,
+ order: 1,
+ wholeWord: false,
},
];
const ctx = createMockContext(rules, 'The cat and the dog
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
- // Note: Our implementation uses 'g' flag, so it will match "the" but not "The"
- // This is expected behavior - regex is case-sensitive by default
expect(result).toContain('THE');
expect(result).toContain('The cat'); // uppercase "The" stays untouched
});
+
+ test('should handle case-insensitive regex when specified', async () => {
+ const rules: ProofreadRule[] = [
+ {
+ id: '1',
+ scope: 'book',
+ pattern: 'the',
+ replacement: 'THE',
+ enabled: true,
+ isRegex: true,
+ caseSensitive: false,
+ order: 1,
+ wholeWord: false,
+ },
+ ];
+ const ctx = createMockContext(rules, 'The cat and the dog
');
+ const result = await proofreadTransformer.transform(ctx);
+
+ // Both "The" and "the" should be replaced
+ expect(result).toContain('THE cat and THE dog');
+ });
});
- describe('case sensitivity (single instance)', () => {
- test('should be case-sensitive by default for single instance', async () => {
- const rules: ReplacementRule[] = [
+ describe('selection scope', () => {
+ test('should skip selection rules without matching sectionHref', async () => {
+ const rules: ProofreadRule[] = [
{
id: '1',
- pattern: 'hello',
- replacement: 'hi',
+ scope: 'selection',
+ pattern: 'test',
+ replacement: 'REPLACED',
enabled: true,
isRegex: false,
- singleInstance: true,
- occurrenceIndex: 0,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
+ sectionHref: 'chapter1.html',
+ cfi: 'epubcfi(/6/14!/4/2,/1:0,/1:4)',
},
];
- const ctx = createMockContext(rules, 'Hello world hello there
');
- const result = await replacementTransformer.transform(ctx);
+ const ctx = createMockContext(
+ rules,
+ 'test content
',
+ 'chapter2.html',
+ );
+ const result = await proofreadTransformer.transform(ctx);
- // "hello" (lowercase) should match, "Hello" should not
- expect(result).toContain('Hello world hi there');
- expect(result).not.toContain('hi world hi there');
+ // Should not replace because sectionHref doesn't match
+ expect(result).toContain('test content');
+ expect(result).not.toContain('REPLACED');
});
- test('should replace case-sensitive match at correct occurrence', async () => {
- const rules: ReplacementRule[] = [
+ test('should process selection rules with matching sectionHref', async () => {
+ const rules: ProofreadRule[] = [
{
id: '1',
- pattern: 'hello',
- replacement: 'hi',
+ scope: 'selection',
+ pattern: 'test',
+ replacement: 'REPLACED',
enabled: true,
isRegex: false,
- singleInstance: true,
- occurrenceIndex: 1, // second occurrence
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
+ sectionHref: 'chapter1.html',
+ cfi: 'epubcfi(/6/14!/4/2,/1:0,/1:4)',
},
];
- const ctx = createMockContext(rules, 'hello world and hello again
');
- const result = await replacementTransformer.transform(ctx);
+ const ctx = createMockContext(
+ rules,
+ 'test content
',
+ 'chapter1.html',
+ );
+ const result = await proofreadTransformer.transform(ctx);
- // Only second "hello" should be replaced
- expect(result).toContain('hello world and hi again');
- const helloCount = (result.match(/hello/g) || []).length;
- const hiCount = (result.match(/hi/g) || []).length;
- expect(helloCount).toBe(1);
- expect(hiCount).toBe(1);
+ expect(result).not.toContain('test content');
+ expect(result).toContain('REPLACED');
+ });
+
+ test('should handle selection rules with hash fragments in sectionHref', async () => {
+ const rules: ProofreadRule[] = [
+ {
+ id: '1',
+ scope: 'selection',
+ pattern: 'test',
+ replacement: 'REPLACED',
+ enabled: true,
+ isRegex: false,
+ caseSensitive: true,
+ order: 1,
+ wholeWord: true,
+ sectionHref: 'chapter1.html#section2',
+ cfi: 'epubcfi(/6/14!/4/2,/1:0,/1:4)',
+ },
+ ];
+ const ctx = createMockContext(
+ rules,
+ 'test content
',
+ 'chapter1.html#section3',
+ );
+ const result = await proofreadTransformer.transform(ctx);
+
+ expect(result).not.toContain('test content');
+ expect(result).toContain('REPLACED');
+ });
+
+ test('should not process selection rules without sectionHref', async () => {
+ const rules: ProofreadRule[] = [
+ {
+ id: '1',
+ scope: 'selection',
+ pattern: 'test',
+ replacement: 'REPLACED',
+ enabled: true,
+ isRegex: false,
+ caseSensitive: true,
+ order: 1,
+ wholeWord: true,
+ cfi: 'epubcfi(/6/14!/4/2,/1:0,/1:4)',
+ // No sectionHref
+ },
+ ];
+ const ctx = createMockContext(
+ rules,
+ 'test content
',
+ 'chapter1.html',
+ );
+ const result = await proofreadTransformer.transform(ctx);
+
+ // Selection rules without sectionHref should be skipped
+ expect(result).toContain('test content');
+ });
+
+ test('should handle invalid CFI gracefully', async () => {
+ const rules: ProofreadRule[] = [
+ {
+ id: '1',
+ scope: 'selection',
+ pattern: 'test',
+ replacement: 'REPLACED',
+ enabled: true,
+ isRegex: false,
+ caseSensitive: true,
+ order: 1,
+ wholeWord: true,
+ sectionHref: 'chapter1.html',
+ cfi: 'invalid-cfi',
+ },
+ ];
+ const ctx = createMockContext(rules, 'test content
', 'chapter1.html');
+ const result = await proofreadTransformer.transform(ctx);
+
+ // Should not crash, content should remain unchanged
+ expect(result).toBeDefined();
+ expect(result).toContain('test');
});
});
describe('case sensitivity (book scope)', () => {
test('should be case-sensitive by default for book scope', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'hello',
replacement: 'hi',
enabled: true,
isRegex: false,
- singleInstance: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'Hello world hello there Hello
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
// Only lowercase "hello" should match
expect(result).toContain('Hello world hi there Hello');
- const helloCount = (result.match(/[Hh]ello/g) || []).length;
- const hiCount = (result.match(/hi/g) || []).length;
+ const helloCount = (result.match(/Hello/g) || []).length;
+ const hiCount = (result.match(/\bhi\b/g) || []).length;
expect(helloCount).toBe(2); // Two "Hello" remain
expect(hiCount).toBe(1); // One "hello" replaced
});
test('should replace all case-sensitive matches in book scope', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'world',
replacement: 'universe',
enabled: true,
isRegex: false,
- singleInstance: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'world and world and World
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
// Both lowercase "world" should match, "World" should not
expect(result).toContain('universe and universe and World');
- const worldCount = (result.match(/[Ww]orld/g) || []).length;
+ const worldCount = (result.match(/World/g) || []).length;
const universeCount = (result.match(/universe/g) || []).length;
expect(worldCount).toBe(1); // One "World" remains
expect(universeCount).toBe(2);
});
});
- describe('case sensitivity (global scope)', () => {
- test('should be case-sensitive by default for global scope', async () => {
- // Simulate global rules via the merged rules mechanism
- const globalRules: ReplacementRule[] = [
+ describe('case sensitivity (library scope)', () => {
+ test('should be case-sensitive by default for library scope', async () => {
+ const rules: ProofreadRule[] = [
{
- id: 'global-1',
+ id: 'library-1',
+ scope: 'library',
pattern: 'book',
replacement: 'tome',
enabled: true,
isRegex: false,
- singleInstance: false,
- global: true,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
- const ctx = createMockContext(globalRules, 'book and Book and BOOK
');
- const result = await replacementTransformer.transform(ctx);
+ const ctx = createMockContext(rules, 'book and Book and BOOK
');
+ const result = await proofreadTransformer.transform(ctx);
// Only lowercase "book" should match
expect(result).toContain('tome and Book and BOOK');
- const bookCount = (result.match(/[Bb]ook|BOOK/g) || []).length;
+ const bookCount = (result.match(/Book|BOOK/g) || []).length;
const tomeCount = (result.match(/tome/g) || []).length;
expect(bookCount).toBe(2); // "Book" and "BOOK" remain
expect(tomeCount).toBe(1);
});
- test('should replace all case-sensitive matches across global scope', async () => {
- const globalRules: ReplacementRule[] = [
+ test('should replace all case-sensitive matches across library scope', async () => {
+ const rules: ProofreadRule[] = [
{
- id: 'global-1',
+ id: 'library-1',
+ scope: 'library',
pattern: 'test',
replacement: 'exam',
enabled: true,
isRegex: false,
- singleInstance: false,
- global: true,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
- const ctx = createMockContext(globalRules, 'test and test and Test and TEST
');
- const result = await replacementTransformer.transform(ctx);
+ const ctx = createMockContext(rules, 'test and test and Test and TEST
');
+ const result = await proofreadTransformer.transform(ctx);
// Only lowercase "test" should match
expect(result).toContain('exam and exam and Test and TEST');
- const testCount = (result.match(/[Tt]est|TEST/g) || []).length;
+ const testCount = (result.match(/Test|TEST/g) || []).length;
const examCount = (result.match(/exam/g) || []).length;
expect(testCount).toBe(2); // "Test" and "TEST" remain
expect(examCount).toBe(2);
});
});
- describe('case sensitivity toggle (single instance)', () => {
- test('should respect case-sensitive toggle for single instance', async () => {
- const rules: ReplacementRule[] = [
- {
- id: '1',
- pattern: 'hello',
- replacement: 'hi',
- enabled: true,
- isRegex: false,
- singleInstance: true,
- occurrenceIndex: 0,
- caseSensitive: true, // Explicitly case-sensitive
- order: 1,
- },
- ];
- const ctx = createMockContext(rules, 'Hello world hello there
');
- const result = await replacementTransformer.transform(ctx);
-
- // Only exact case match should be replaced
- expect(result).toContain('Hello world hi there');
- });
-
- test('should respect case-insensitive toggle for single instance (explicit)', async () => {
- const rules: ReplacementRule[] = [
- {
- id: '1',
- pattern: 'hello',
- replacement: 'hi',
- enabled: true,
- isRegex: false,
- singleInstance: true,
- occurrenceIndex: 0,
- caseSensitive: false, // Case-insensitive but will be ignored
- order: 1,
- },
- ];
- const ctx = createMockContext(rules, 'Hello world hello there
');
- const result = await replacementTransformer.transform(ctx);
-
- // First match should be replaced, case sensitve is set to true by default for single instance
- expect(result).toContain('Hello world hi there');
- const hiCount = (result.match(/hi/g) || []).length;
- expect(hiCount).toBe(1);
- });
- });
-
describe('case sensitivity toggle (book scope)', () => {
test('should replace case-sensitive when flag is true', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'test',
replacement: 'exam',
enabled: true,
isRegex: false,
- singleInstance: false,
- caseSensitive: true, // Case-sensitive
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'test Test TEST
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
// Only lowercase "test" should be replaced
expect(result).toContain('exam Test TEST');
});
- test('should replace case-insensitive when flag is false (explicit)', async () => {
- const rules: ReplacementRule[] = [
+ test('should replace case-insensitive when flag is false', async () => {
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'test',
replacement: 'exam',
enabled: true,
isRegex: false,
- singleInstance: false,
- caseSensitive: false, // Case-insensitive (explicitly set)
+ caseSensitive: false,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'test Test TEST
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
// All variants should be replaced
expect(result).toContain('exam exam exam');
});
test('should replace all occurrences case-insensitively with toggle', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'hello',
replacement: 'hi',
enabled: true,
isRegex: false,
- singleInstance: false,
- caseSensitive: false, // Case-insensitive
+ caseSensitive: false,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'hello Hello HELLO
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
// All should be replaced
expect(result).toContain('hi hi hi');
- const hiCount = (result.match(/hi/g) || []).length;
+ const hiCount = (result.match(/\bhi\b/gi) || []).length;
expect(hiCount).toBe(3);
});
});
- describe('case sensitivity toggle (global scope)', () => {
- test('should be case-sensitive when flag is true in global scope', async () => {
- const globalRules: ReplacementRule[] = [
+ describe('case sensitivity toggle (library scope)', () => {
+ test('should be case-sensitive when flag is true in library scope', async () => {
+ const rules: ProofreadRule[] = [
{
- id: 'global-1',
+ id: 'library-1',
+ scope: 'library',
pattern: 'world',
replacement: 'universe',
enabled: true,
isRegex: false,
- singleInstance: false,
- caseSensitive: true, // Explicitly case-sensitive
- global: true,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
- const ctx = createMockContext(globalRules, 'world World WORLD
');
- const result = await replacementTransformer.transform(ctx);
+ const ctx = createMockContext(rules, 'world World WORLD
');
+ const result = await proofreadTransformer.transform(ctx);
// Only lowercase "world" replaced
expect(result).toContain('universe World WORLD');
});
- test('should be case-insensitive when flag is false (explicit) in global scope', async () => {
- const globalRules: ReplacementRule[] = [
+ test('should be case-insensitive when flag is false in library scope', async () => {
+ const rules: ProofreadRule[] = [
{
- id: 'global-1',
+ id: 'library-1',
+ scope: 'library',
pattern: 'world',
replacement: 'universe',
enabled: true,
isRegex: false,
- singleInstance: false,
- caseSensitive: false, // Case-insensitive
- global: true,
+ caseSensitive: false,
order: 1,
+ wholeWord: true,
},
];
- const ctx = createMockContext(globalRules, 'world World WORLD
');
- const result = await replacementTransformer.transform(ctx);
+ const ctx = createMockContext(rules, 'world World WORLD
');
+ const result = await proofreadTransformer.transform(ctx);
// All should be replaced
expect(result).toContain('universe universe universe');
- const universeCount = (result.match(/universe/g) || []).length;
+ const universeCount = (result.match(/universe/gi) || []).length;
expect(universeCount).toBe(3);
});
});
describe('scope precedence', () => {
- test('single-instance should override book/global for that occurrence', async () => {
- const rules: ReplacementRule[] = [
+ test('selection should be processed first, then book, then library', async () => {
+ const rules: ProofreadRule[] = [
{
- id: 'single-1',
- pattern: 'Hello',
- replacement: 'Hi-once',
+ id: 'library-1',
+ scope: 'library',
+ pattern: 'world',
+ replacement: 'LIBRARY',
enabled: true,
isRegex: false,
- singleInstance: true,
- occurrenceIndex: 0,
- sectionHref: 'chap1',
- order: 1,
- },
- {
- id: 'book-1',
- pattern: 'Hello',
- replacement: 'Hi-book',
- enabled: true,
- isRegex: false,
- singleInstance: false,
- order: 2,
- },
- {
- id: 'global-1',
- pattern: 'Hello',
- replacement: 'Hi-global',
- enabled: true,
- isRegex: false,
- singleInstance: false,
- global: true,
+ caseSensitive: true,
order: 3,
+ wholeWord: true,
},
- ];
-
- const ctx = createMockContext(rules, 'Hello Hello
');
- // Simulate sectionHref to match single-instance rule
- ctx.sectionHref = 'chap1';
-
- const result = await replacementTransformer.transform(ctx);
-
- // First occurrence should use single-instance replacement; second should fall to book (before global)
- expect(result).toContain('Hi-once Hi-book');
- expect(result).not.toContain('Hi-global');
- });
-
- test('book should win over global for same pattern', async () => {
- const rules: ReplacementRule[] = [
{
id: 'book-1',
+ scope: 'book',
pattern: 'world',
replacement: 'BOOK',
enabled: true,
isRegex: false,
- singleInstance: false,
- order: 1,
- },
- {
- id: 'global-1',
- pattern: 'world',
- replacement: 'GLOBAL',
- enabled: true,
- isRegex: false,
- singleInstance: false,
- global: true,
+ caseSensitive: true,
order: 2,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'world world
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
- // Book-scope replacement should apply; global should not override
+ // Book-scope replacement should apply first due to scope ordering
expect(result).toContain('BOOK BOOK');
- expect(result).not.toContain('GLOBAL');
+ expect(result).not.toContain('LIBRARY');
+ });
+
+ test('should respect order within same scope', async () => {
+ const rules: ProofreadRule[] = [
+ {
+ id: '2',
+ scope: 'book',
+ pattern: 'cat',
+ replacement: 'dog',
+ enabled: true,
+ isRegex: false,
+ caseSensitive: true,
+ order: 2,
+ wholeWord: true,
+ },
+ {
+ id: '1',
+ scope: 'book',
+ pattern: 'The',
+ replacement: 'A',
+ enabled: true,
+ isRegex: false,
+ caseSensitive: true,
+ order: 1,
+ wholeWord: true,
+ },
+ ];
+ const ctx = createMockContext(rules, 'The cat sat
');
+ const result = await proofreadTransformer.transform(ctx);
+
+ // First "The" -> "A" (order 1), then "cat" -> "dog" (order 2)
+ expect(result).toContain('A dog sat');
});
});
describe('rule ordering', () => {
test('should apply rules in order (lower order numbers first)', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '2',
+ scope: 'book',
pattern: 'cat',
replacement: 'dog',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 2,
+ wholeWord: true,
},
{
id: '1',
+ scope: 'book',
pattern: 'The',
replacement: 'A',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'The cat sat
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
- // First "The" -> "A" (order 1), then "cat" -> "dog" (order 2)
expect(result).toContain('A dog sat');
});
test('should handle rules with same order', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'a',
replacement: 'A',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
{
id: '2',
+ scope: 'book',
pattern: 'b',
replacement: 'B',
enabled: true,
isRegex: false,
- order: 1, // Same order
+ caseSensitive: true,
+ order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'a b c
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
- // Both should be applied (whole-word matching)
+ // Both should be applied
expect(result).toContain('A B c');
});
});
describe('enabled/disabled rules', () => {
test('should skip disabled rules', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'Hello',
replacement: 'Hi',
enabled: false,
isRegex: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'Hello world
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
expect(result).toContain('Hello');
expect(result).not.toContain('Hi');
});
test('should only apply enabled rules', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'Hello',
replacement: 'Hi',
enabled: false,
isRegex: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
{
id: '2',
+ scope: 'book',
pattern: 'world',
replacement: 'universe',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 2,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'Hello world
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
- expect(result).toContain('Hello'); // Not replaced (disabled)
- expect(result).toContain('universe'); // Replaced (enabled)
+ expect(result).toContain('Hello');
+ expect(result).toContain('universe');
});
});
describe('error handling', () => {
test('should handle invalid regex gracefully', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: '[invalid',
replacement: 'fixed',
enabled: true,
isRegex: true,
+ caseSensitive: true,
order: 1,
+ wholeWord: false,
},
];
const ctx = createMockContext(rules, 'Test content
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
- expect(result).toContain('Test content'); // Content unchanged
+ expect(result).toContain('Test content');
});
test('should continue processing other rules after invalid regex', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: '[invalid',
replacement: 'fixed',
enabled: true,
isRegex: true,
+ caseSensitive: true,
order: 1,
+ wholeWord: false,
},
{
id: '2',
+ scope: 'book',
pattern: 'Test',
replacement: 'PASSED',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 2,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'Test content
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
- expect(result).toContain('PASSED'); // Second rule should still work
+ expect(result).toContain('PASSED');
});
});
describe('HTML preservation', () => {
test('should preserve HTML structure', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'text',
replacement: 'TEXT',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'Some text here
More text ');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
expect(result).toContain('');
expect(result).toContain('
');
@@ -795,21 +923,24 @@ describe('replacementTransformer', () => {
});
test('should skip script and style tags', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'text',
replacement: 'TEXT',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(
rules,
'Some text
',
);
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
// Text in should be replaced
expect(result).toContain('Some TEXT');
@@ -821,145 +952,132 @@ describe('replacementTransformer', () => {
describe('unicode and special characters', () => {
test('should handle unicode characters', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'café',
replacement: 'cafe',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 1,
wholeWord: true,
},
];
const ctx = createMockContext(rules, '
café
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
expect(result).toContain('cafe');
expect(result).not.toContain('café');
});
test('should handle special regex characters in simple mode', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'a.b',
replacement: 'A.B',
enabled: true,
- isRegex: false, // Simple mode should escape special chars
+ isRegex: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'a.b and aXb
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
- expect(result).toContain('A.B'); // Exact match replaced
- expect(result).toContain('aXb'); // Not replaced (not exact match)
- });
-
- test('should handle special regex characters in simple mode (single-instance)', async () => {
- const rules: ReplacementRule[] = [
- {
- id: '1',
- pattern: 'a.b',
- replacement: 'A.B',
- enabled: true,
- isRegex: false, // literal match
- singleInstance: true, // only first occurrence
- occurrenceIndex: 0, // replace only the first one
- order: 1,
- },
- ];
-
- const input = 'aXb and a.b and a.b
';
-
- const ctx = createMockContext(rules, input);
- const result = await replacementTransformer.transform(ctx);
-
- // Only the first literal "a.b" should be replaced → "A.B"
- expect(result).toContain('A.B and a.b'); // second "a.b" remains
-
- // aXb must NOT be replaced (the "." does NOT match X)
+ expect(result).toContain('A.B');
expect(result).toContain('aXb');
-
- // Ensure only *one* instance was replaced
- const replacedCount = (result.match(/A\.B/g) || []).length;
- expect(replacedCount).toBe(1);
});
});
describe('edge cases', () => {
test('should handle empty pattern', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: '',
replacement: 'X',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'test
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
- // empty pattern produces no changes
+ // empty pattern produces no changes (filtered out by .filter(r => r.pattern.trim()))
expect(result).toBe(ctx.content);
});
test('should handle empty replacement', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'test',
replacement: '',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'test content
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
expect(result).not.toContain('test');
- expect(result).toContain(' content');
+ expect(result).toContain('content');
});
test('should handle rules with undefined order', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'test',
replacement: 'TEST',
enabled: true,
isRegex: false,
+ caseSensitive: true,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
order: undefined as any,
+ wholeWord: true,
},
];
const ctx = createMockContext(rules, 'test
');
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
expect(result).toContain('TEST');
});
test('should handle complex HTML with nested elements', async () => {
- const rules: ReplacementRule[] = [
+ const rules: ProofreadRule[] = [
{
id: '1',
+ scope: 'book',
pattern: 'text',
replacement: 'TEXT',
enabled: true,
isRegex: false,
+ caseSensitive: true,
order: 1,
+ wholeWord: true,
},
];
const ctx = createMockContext(
rules,
'',
);
- const result = await replacementTransformer.transform(ctx);
+ const result = await proofreadTransformer.transform(ctx);
expect(result).toContain('Some TEXT');
expect(result).toContain('More TEXT');
@@ -968,188 +1086,27 @@ describe('replacementTransformer', () => {
});
});
- describe('logging', () => {
- test('should log transformer call with correct information', async () => {
- const rules: ReplacementRule[] = [
- {
- id: '1',
- pattern: 'test',
- replacement: 'TEST',
- enabled: true,
- isRegex: false,
- order: 1,
- },
- ];
- const ctx = createMockContext(rules, 'test
');
-
- await replacementTransformer.transform(ctx);
- });
- });
-
- describe('replacement rule management functions', () => {
- describe('createReplacementRule', () => {
- test('should create a rule with default values', () => {
- const rule = createReplacementRule({
- pattern: 'test',
- replacement: 'TEST',
- });
-
- expect(rule).toMatchObject({
- pattern: 'test',
- replacement: 'TEST',
- isRegex: false,
- enabled: true,
- order: 1000,
- });
- expect(rule.id).toBeDefined();
- expect(typeof rule.id).toBe('string');
- });
-
- test('should create a rule with custom values', () => {
- const rule = createReplacementRule({
- pattern: '\\d+',
- replacement: 'NUMBER',
- isRegex: true,
- enabled: false,
- order: 1,
- });
-
- expect(rule).toMatchObject({
- pattern: '\\d+',
- replacement: 'NUMBER',
- isRegex: true,
- enabled: false,
- order: 1,
- });
- });
+ describe('validateReplacementRulePattern', () => {
+ test('should validate simple string pattern', () => {
+ const result = validateReplacementRulePattern('test', false);
+ expect(result.valid).toBe(true);
});
- describe('mergeReplacementRules', () => {
- test('should merge global and book rules', () => {
- const globalRules: ReplacementRule[] = [
- {
- id: 'global-1',
- pattern: 'the',
- replacement: 'THE',
- enabled: true,
- isRegex: false,
- order: 1,
- },
- ];
-
- const bookRules: ReplacementRule[] = [
- {
- id: 'book-1',
- pattern: 'cat',
- replacement: 'dog',
- enabled: true,
- isRegex: false,
- order: 2,
- },
- ];
-
- const merged = mergeReplacementRules(globalRules, bookRules);
-
- expect(merged).toHaveLength(2);
- expect(merged[0]!.id).toBe('global-1');
- expect(merged[1]!.id).toBe('book-1');
- });
-
- test('should prioritize book rules over global rules with same ID', () => {
- const globalRules: ReplacementRule[] = [
- {
- id: 'rule-1',
- pattern: 'the',
- replacement: 'THE',
- enabled: true,
- isRegex: false,
- order: 1,
- },
- ];
-
- const bookRules: ReplacementRule[] = [
- {
- id: 'rule-1',
- pattern: 'the',
- replacement: '>THE<',
- enabled: true,
- isRegex: false,
- order: 1,
- },
- ];
-
- const merged = mergeReplacementRules(globalRules, bookRules);
-
- expect(merged).toHaveLength(1);
- expect(merged[0]!.replacement).toBe('>THE<'); // Book rule wins
- });
-
- test('should sort rules by order', () => {
- const globalRules: ReplacementRule[] = [
- {
- id: 'rule-3',
- pattern: 'c',
- replacement: 'C',
- enabled: true,
- isRegex: false,
- order: 3,
- },
- {
- id: 'rule-1',
- pattern: 'a',
- replacement: 'A',
- enabled: true,
- isRegex: false,
- order: 1,
- },
- ];
-
- const bookRules: ReplacementRule[] = [
- {
- id: 'rule-2',
- pattern: 'b',
- replacement: 'B',
- enabled: true,
- isRegex: false,
- order: 2,
- },
- ];
-
- const merged = mergeReplacementRules(globalRules, bookRules);
-
- expect(merged[0]!.pattern).toBe('a');
- expect(merged[1]!.pattern).toBe('b');
- expect(merged[2]!.pattern).toBe('c');
- });
-
- test('should handle undefined rules', () => {
- const merged = mergeReplacementRules(undefined, undefined);
- expect(merged).toEqual([]);
- });
+ test('should reject empty pattern', () => {
+ const result = validateReplacementRulePattern('', false);
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('empty');
});
- describe('validateReplacementRulePattern', () => {
- test('should validate simple string pattern', () => {
- const result = validateReplacementRulePattern('test', false);
- expect(result.valid).toBe(true);
- });
+ test('should validate valid regex pattern', () => {
+ const result = validateReplacementRulePattern('\\d+', true);
+ expect(result.valid).toBe(true);
+ });
- test('should reject empty pattern', () => {
- const result = validateReplacementRulePattern('', false);
- expect(result.valid).toBe(false);
- expect(result.error).toContain('empty');
- });
-
- test('should validate valid regex pattern', () => {
- const result = validateReplacementRulePattern('\\d+', true);
- expect(result.valid).toBe(true);
- });
-
- test('should reject invalid regex pattern', () => {
- const result = validateReplacementRulePattern('[invalid', true);
- expect(result.valid).toBe(false);
- expect(result.error).toBeDefined();
- });
+ test('should reject invalid regex pattern', () => {
+ const result = validateReplacementRulePattern('[invalid', true);
+ expect(result.valid).toBe(false);
+ expect(result.error).toBeDefined();
});
});
});
diff --git a/apps/readest-app/src/__tests__/utils/simplecc.test.ts b/apps/readest-app/src/__tests__/utils/simplecc.test.ts
index 5df5217e..ed87f551 100644
--- a/apps/readest-app/src/__tests__/utils/simplecc.test.ts
+++ b/apps/readest-app/src/__tests__/utils/simplecc.test.ts
@@ -7,7 +7,7 @@ describe.concurrent('suite', () => {
beforeAll(async () => {
const wasmPath = join(process.cwd(), 'public/vendor/simplecc/simplecc_wasm_bg.wasm');
const wasmBuffer = await readFile(wasmPath);
- await init(wasmBuffer);
+ await init({ module_or_path: wasmBuffer });
});
test('basic s2t and t2s', () => {
diff --git a/apps/readest-app/src/__tests__/utils/wordLimit.test.ts b/apps/readest-app/src/__tests__/utils/word.test.ts
similarity index 82%
rename from apps/readest-app/src/__tests__/utils/wordLimit.test.ts
rename to apps/readest-app/src/__tests__/utils/word.test.ts
index ed4f53b1..7ae08fdf 100644
--- a/apps/readest-app/src/__tests__/utils/wordLimit.test.ts
+++ b/apps/readest-app/src/__tests__/utils/word.test.ts
@@ -1,5 +1,5 @@
import { describe, it, expect } from 'vitest';
-import { getWordCount, isWordLimitExceeded } from '../../utils/wordLimit';
+import { getWordCount } from '../../utils/word';
describe('Word Limit Feature', () => {
describe('getWordCount', () => {
@@ -49,49 +49,6 @@ describe('Word Limit Feature', () => {
const thirtyOneWords = Array(31).fill('word').join(' ');
expect(getWordCount(thirtyOneWords)).toBe(31);
});
- });
-
- describe('isWordLimitExceeded', () => {
- it('should return false for text under 30 words', () => {
- expect(isWordLimitExceeded('hello world')).toBe(false);
- expect(isWordLimitExceeded('a')).toBe(false);
- });
-
- it('should return false for exactly 30 words', () => {
- const thirtyWords = Array(30).fill('word').join(' ');
- expect(isWordLimitExceeded(thirtyWords)).toBe(false);
- });
-
- it('should return true for 31 words', () => {
- const thirtyOneWords = Array(31).fill('word').join(' ');
- expect(isWordLimitExceeded(thirtyOneWords)).toBe(true);
- });
-
- it('should return true for many words', () => {
- const manyWords = Array(100).fill('word').join(' ');
- expect(isWordLimitExceeded(manyWords)).toBe(true);
- });
-
- it('should return false for empty string', () => {
- expect(isWordLimitExceeded('')).toBe(false);
- });
- });
-
- describe('Edge cases', () => {
- it('should handle very long words', () => {
- const longWord = 'a'.repeat(1000);
- expect(getWordCount(longWord)).toBe(1);
- expect(isWordLimitExceeded(longWord)).toBe(false);
- });
-
- it('should handle mixed content with newlines', () => {
- const text = `Line one with words.
- Line two with more words.
- Line three.`;
- // "Line one with words." = 4, "Line two with more words." = 5, "Line three." = 2 = 11 total
- expect(getWordCount(text)).toBe(11);
- expect(isWordLimitExceeded(text)).toBe(false);
- });
it('should handle unicode characters', () => {
expect(getWordCount('你好 世界')).toBe(2);
@@ -104,6 +61,21 @@ describe('Word Limit Feature', () => {
expect(getWordCount('chapter 1 section 2')).toBe(4);
});
});
+
+ describe('Edge cases', () => {
+ it('should handle very long words', () => {
+ const longWord = 'a'.repeat(1000);
+ expect(getWordCount(longWord)).toBe(1);
+ });
+
+ it('should handle mixed content with newlines', () => {
+ const text = `Line one with words.
+ Line two with more words.
+ Line three.`;
+ // "Line one with words." = 4, "Line two with more words." = 5, "Line three." = 2 = 11 total
+ expect(getWordCount(text)).toBe(11);
+ });
+ });
});
describe('Case Sensitivity Matching', () => {
diff --git a/apps/readest-app/src/app/reader/components/FoliateViewer.tsx b/apps/readest-app/src/app/reader/components/FoliateViewer.tsx
index 59a55f09..705ba80b 100644
--- a/apps/readest-app/src/app/reader/components/FoliateViewer.tsx
+++ b/apps/readest-app/src/app/reader/components/FoliateViewer.tsx
@@ -141,6 +141,7 @@ const FoliateViewer: React.FC<{
primaryLanguage: bookData.book?.primaryLanguage,
userLocale: getLocale(),
content: data,
+ sectionHref: detail.name,
transformers: [
'style',
'punctuation',
@@ -149,9 +150,8 @@ const FoliateViewer: React.FC<{
'language',
'sanitizer',
'simplecc',
- 'replacement',
+ 'proofread',
],
- sectionHref: detail.name, // Pass section href for single-instance replacements
};
return Promise.resolve(transformContent(ctx));
}
diff --git a/apps/readest-app/src/app/reader/components/ProofreadRules.tsx b/apps/readest-app/src/app/reader/components/ProofreadRules.tsx
new file mode 100644
index 00000000..46a2e141
--- /dev/null
+++ b/apps/readest-app/src/app/reader/components/ProofreadRules.tsx
@@ -0,0 +1,307 @@
+import clsx from 'clsx';
+import React, { useEffect, useState } from 'react';
+import { RiEditLine, RiDeleteBin7Line } from 'react-icons/ri';
+import { useEnv } from '@/context/EnvContext';
+import { useTranslation } from '@/hooks/useTranslation';
+import { useSettingsStore } from '@/store/settingsStore';
+import { useReaderStore } from '@/store/readerStore';
+import { useSidebarStore } from '@/store/sidebarStore';
+import { useBookDataStore } from '@/store/bookDataStore';
+import { useProofreadStore } from '@/store/proofreadStore';
+import { ProofreadRule, ProofreadScope } from '@/types/book';
+import { eventDispatcher } from '@/utils/event';
+import Dialog from '@/components/Dialog';
+
+const dialogId = 'proofread_rules_window';
+
+export const setProofreadRulesVisibility = (visible: boolean) => {
+ const dialog = document.getElementById(dialogId);
+ if (dialog) {
+ dialog.dispatchEvent(new CustomEvent('setProofreadRulesVisibility', { detail: { visible } }));
+ }
+};
+
+const RuleItem: React.FC<{
+ rule: ProofreadRule;
+ scope: ProofreadScope;
+ isEditing: boolean;
+ editingData: { pattern: string; replacement: string; enabled: boolean };
+ onEdit: () => void;
+ onDelete: () => void;
+ onSave: () => void;
+ onCancel: () => void;
+ onEditChange: (field: 'replacement', value: string) => void;
+}> = ({
+ rule,
+ scope,
+ isEditing,
+ editingData,
+ onEdit,
+ onDelete,
+ onSave,
+ onCancel,
+ onEditChange,
+}) => {
+ const _ = useTranslation();
+ const { sideBarBookKey } = useSidebarStore();
+ const { getView } = useReaderStore();
+
+ const navigateToSelection = () => {
+ if (!sideBarBookKey || !rule.cfi) return;
+ eventDispatcher.dispatch('navigate', { bookKey: sideBarBookKey, cfi: rule.cfi });
+ getView(sideBarBookKey)?.goTo(rule.cfi);
+ };
+
+ if (isEditing) {
+ return (
+
+
+ {_('Selected text:')}
+
+
+
+ {_('Replace with:')}
+
+
+
+
+ {_('Save')}
+
+
+ {_('Cancel')}
+
+
+
+
+
{rule.pattern}
+
+
+ {_('Replace with:')}
+
+ {rule.replacement}
+
+
+
+ {_('Scope:')}
+
+ {scope === 'selection' ? _('Selection') : scope === 'book' ? _('Book') : _('Library')}
+
+
+ •
+
+ {_('Case sensitive:')}
+
+ {rule.caseSensitive !== false ? _('Yes') : _('No')}
+
+
+
+
+
+
+
+
+
+
+
+
{title}
+ {rules.length === 0 ? (
+
+ ) : (
+
+ {rules.map((rule) => (
+
+ startEdit(rule, scopeType === 'selection' ? 'selection' : rule.scope)}
+ onDelete={() =>
+ deleteRule(rule.id, scopeType === 'selection' ? 'selection' : rule.scope)
+ }
+ onSave={saveEdit}
+ onCancel={cancelEdit}
+ onEditChange={(_, value) => setEditing({ ...editing, replacement: value })}
+ />
+
+ ))}
+
+ )}
+
setIsOpen(false)}
+ title={_('Proofread Replacement Rules')}
+ boxClassName='sm:!min-w-[560px] sm:!max-w-[640px] sm:h-auto'
+ >
+ {isOpen && (
+
+ {renderRuleList(
+ singleRules,
+ 'selection',
+ _('Selected Text Rules'),
+ _('No selected text replacement rules'),
+ )}
+ {renderRuleList(
+ bookRules,
+ 'book',
+ _('Book Specific Rules'),
+ _('No book-level replacement rules'),
+ )}
+
+
+ );
+};
+
+export default ProofreadRulesManager;
diff --git a/apps/readest-app/src/app/reader/components/Reader.tsx b/apps/readest-app/src/app/reader/components/Reader.tsx
index 8d0c1b03..9a365860 100644
--- a/apps/readest-app/src/app/reader/components/Reader.tsx
+++ b/apps/readest-app/src/app/reader/components/Reader.tsx
@@ -23,7 +23,7 @@ import { getSysFontsList, setSystemUIVisibility } from '@/utils/bridge';
import { AboutWindow } from '@/components/AboutWindow';
import { UpdaterWindow } from '@/components/UpdaterWindow';
import { KOSyncSettingsWindow } from './KOSyncSettings';
-import { ReplacementRulesWindow } from './ReplacementRulesWindow';
+import { ProofreadRulesManager } from './ProofreadRules';
import { Toast } from '@/components/Toast';
import { getLocale } from '@/utils/misc';
import { initDayjs } from '@/utils/time';
@@ -161,7 +161,7 @@ const Reader: React.FC<{ ids?: string }> = ({ ids }) => {
setIsOpen(false)}
- title={_('Replacement Rules')}
- boxClassName='sm:!min-w-[520px] sm:h-auto'
- >
- {isOpen && (
-
-
-
{_('Single Instance Rules')}
- {singleRules.length === 0 ? (
-
- {_('No single replacement rules')}
-
- ) : (
-
- {singleRules.map((r) => (
-
- {editing.id === r.id && editing.scope === 'single' ? (
-
-
-
- {_('Selected phrase:')}
-
-
-
-
-
- {_('Replace with:')}
-
-
-
-
-
- {_('Save')}
-
-
- {_('Cancel')}
-
-
-
-
-
{r.pattern}
-
-
- {_('Replace with:')}
-
- {r.replacement}
-
-
- {_('Scope:')} Single Instance
- | {_('Case sensitive:')}
-
- {r.caseSensitive !== false ? _('Yes') : _('No')}
-
-
-
-
- startEdit(r, 'single')}
- aria-label={_('Edit')}
- >
-
- deleteRule(r.id, 'single')}
- aria-label={_('Delete')}
- >
-
-
-
- ))}
-
- )}
-
-
{_('Book Specific Rules')}
- {bookRules.length === 0 ? (
-
- {_('No book-level replacement rules')}
-
- ) : (
-
- {bookRules.map((r) => {
- const ruleScope = getRuleScope(r);
- const isEditing = editing.id === r.id && editing.scope === ruleScope;
- return (
-
- {isEditing ? (
-
-
-
- {_('Selected phrase:')}
-
-
-
-
-
- {_('Replace with:')}
-
-
-
-
-
- {_('Save')}
-
-
- {_('Cancel')}
-
-
-
-
-
{r.pattern}
-
-
- {_('Replace with:')}
-
- {r.replacement}
-
-
- {_('Scope:')}
-
- {getRuleScope(r) === 'book' ? _('Book') : _('Global')}
-
- | {_('Case sensitive:')}
-
- {r.caseSensitive !== false ? _('Yes') : _('No')}
-
-
-
-
- startEdit(r, getRuleScope(r))}
- aria-label={_('Edit')}
- >
-
- deleteRule(r.id, ruleScope)}
- aria-label={_('Delete')}
- >
-
-
-
- );
- })}
-
- )}
-
-
- );
-};
-
-export default ReplacementRulesWindow;
diff --git a/apps/readest-app/src/app/reader/components/annotator/Annotator.tsx b/apps/readest-app/src/app/reader/components/annotator/Annotator.tsx
index 0dc8ba7d..539ef721 100644
--- a/apps/readest-app/src/app/reader/components/annotator/Annotator.tsx
+++ b/apps/readest-app/src/app/reader/components/annotator/Annotator.tsx
@@ -8,7 +8,7 @@ import { RiDeleteBinLine } from 'react-icons/ri';
import { BsTranslate } from 'react-icons/bs';
import { TbHexagonLetterD } from 'react-icons/tb';
import { FaHeadphones } from 'react-icons/fa6';
-import { MdBuildCircle } from 'react-icons/md';
+import { IoIosBuild } from 'react-icons/io';
import * as CFI from 'foliate-js/epubcfi.js';
import { Overlayer } from 'foliate-js/overlayer.js';
@@ -30,15 +30,13 @@ import { findTocItemBS } from '@/utils/toc';
import { throttle } from '@/utils/throttle';
import { runSimpleCC } from '@/utils/simplecc';
import { HIGHLIGHT_COLOR_HEX } from '@/services/constants';
-import { addReplacementRule } from '@/services/transformers/replacement';
+import { getWordCount } from '@/utils/word';
import AnnotationPopup from './AnnotationPopup';
import WiktionaryPopup from './WiktionaryPopup';
import WikipediaPopup from './WikipediaPopup';
import TranslatorPopup from './TranslatorPopup';
import useShortcuts from '@/hooks/useShortcuts';
-import ReplacementOptions from './ReplacementOptions';
-
-import { isWordLimitExceeded } from '@/utils/wordLimit';
+import ProofreadPopup from './ProofreadPopup';
const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
const _ = useTranslation();
@@ -64,11 +62,12 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
const [showWiktionaryPopup, setShowWiktionaryPopup] = useState(false);
const [showWikipediaPopup, setShowWikipediaPopup] = useState(false);
const [showDeepLPopup, setShowDeepLPopup] = useState(false);
- const [showReplacementOptions, setShowReplacementOptions] = useState(false);
+ const [showProofreadPopup, setShowProofreadPopup] = useState(false);
const [trianglePosition, setTrianglePosition] = useState();
const [annotPopupPosition, setAnnotPopupPosition] = useState();
const [dictPopupPosition, setDictPopupPosition] = useState();
const [translatorPopupPosition, setTranslatorPopupPosition] = useState();
+ const [proofreadPopupPosition, setProofreadPopupPosition] = useState();
const [highlightOptionsVisible, setHighlightOptionsVisible] = useState(false);
const [selectedStyle, setSelectedStyle] = useState(
@@ -85,6 +84,8 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
const dictPopupHeight = Math.min(300, maxHeight);
const transPopupWidth = Math.min(480, maxWidth);
const transPopupHeight = Math.min(265, maxHeight);
+ const proofreadPopupWidth = Math.min(440, maxWidth);
+ const proofreadPopupHeight = Math.min(200, maxHeight);
const annotPopupWidth = Math.min(useResponsiveSize(300), maxWidth);
const annotPopupHeight = useResponsiveSize(44);
const androidSelectionHandlerHeight = 0;
@@ -121,10 +122,18 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
transPopupHeight,
popupPadding,
);
+ const proofreadPopupPos = getPopupPosition(
+ triangPos,
+ rect,
+ proofreadPopupWidth,
+ proofreadPopupHeight,
+ popupPadding,
+ );
if (triangPos.point.x == 0 || triangPos.point.y == 0) return;
setAnnotPopupPosition(annotPopupPos);
setDictPopupPosition(dictPopupPos);
setTranslatorPopupPosition(transPopupPos);
+ setProofreadPopupPosition(proofreadPopupPos);
setTrianglePosition(triangPos);
}, [
selection,
@@ -138,6 +147,8 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
dictPopupHeight,
transPopupWidth,
transPopupHeight,
+ proofreadPopupWidth,
+ proofreadPopupHeight,
]);
useEffect(() => {
@@ -156,7 +167,7 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
setShowWiktionaryPopup(false);
setShowWikipediaPopup(false);
setShowDeepLPopup(false);
- setShowReplacementOptions(false);
+ setShowProofreadPopup(false);
}, 500),
[],
);
@@ -213,7 +224,7 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
const range = sel.getRangeAt(0);
const text = sel.toString();
if (text.trim()) {
- setSelection({ key: bookKey, text, range, index });
+ setSelection({ key: bookKey, text, range, index, cfi: view?.getCFI(index, range) });
// Show translation popup preferentially for PDF right-click
setShowAnnotPopup(false);
setShowDeepLPopup(true);
@@ -270,7 +281,14 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
);
const annotation = annotations.find((annotation) => annotation.cfi === cfi);
if (!annotation) return;
- const selection = { key: bookKey, annotated: true, text: annotation.text ?? '', range, index };
+ const selection = {
+ key: bookKey,
+ annotated: true,
+ text: annotation.text ?? '',
+ cfi: view?.getCFI(index, range),
+ range,
+ index,
+ };
setSelectedStyle(annotation.style!);
setSelectedColor(annotation.color!);
setSelection(selection);
@@ -280,16 +298,28 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
useFoliateEvents(view, { onLoad, onDrawAnnotation, onShowAnnotation });
useEffect(() => {
- handleShowPopup(showAnnotPopup || showWiktionaryPopup || showWikipediaPopup || showDeepLPopup);
+ handleShowPopup(
+ showAnnotPopup ||
+ showWiktionaryPopup ||
+ showWikipediaPopup ||
+ showDeepLPopup ||
+ showProofreadPopup,
+ );
// eslint-disable-next-line react-hooks/exhaustive-deps
- }, [showAnnotPopup, showWiktionaryPopup, showWikipediaPopup, showDeepLPopup]);
+ }, [showAnnotPopup, showWiktionaryPopup, showWikipediaPopup, showDeepLPopup, showProofreadPopup]);
// When popups are visible, update their positions on scroll events
useEffect(() => {
const view = getView(bookKey);
if (!view?.renderer) return;
const onScroll = () => {
- if (showAnnotPopup || showWiktionaryPopup || showWikipediaPopup || showDeepLPopup) {
+ if (
+ showAnnotPopup ||
+ showWiktionaryPopup ||
+ showWikipediaPopup ||
+ showDeepLPopup ||
+ showProofreadPopup
+ ) {
repositionPopups();
}
};
@@ -304,6 +334,7 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
showWiktionaryPopup,
showWikipediaPopup,
showDeepLPopup,
+ showProofreadPopup,
repositionPopups,
]);
@@ -347,10 +378,18 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
transPopupHeight,
popupPadding,
);
+ const proofreadPopupPos = getPopupPosition(
+ triangPos,
+ rect,
+ proofreadPopupWidth,
+ proofreadPopupHeight,
+ popupPadding,
+ );
if (triangPos.point.x == 0 || triangPos.point.y == 0) return;
setAnnotPopupPosition(annotPopupPos);
setDictPopupPosition(dictPopupPos);
setTranslatorPopupPosition(transPopupPos);
+ setProofreadPopupPosition(proofreadPopupPos);
setTrianglePosition(triangPos);
handleShowAnnotPopup();
}
@@ -389,13 +428,15 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
setShowWikipediaPopup(false);
};
- const handleCopy = (copyToNotebook = true) => {
+ const handleCopy = (copyToNotebook = true, dismissPopup = true) => {
if (!selection || !selection.text) return;
setTimeout(() => {
// Delay to ensure it won't be overridden by system clipboard actions
navigator.clipboard?.writeText(selection.text);
}, 100);
- handleDismissPopupAndSelection();
+ if (dismissPopup) {
+ handleDismissPopupAndSelection();
+ }
if (!copyToNotebook) return;
@@ -474,7 +515,7 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
} else {
annotations.push(annotation);
views.forEach((view) => view?.addAnnotation(annotation));
- setSelection({ ...selection, annotated: true });
+ setSelection({ ...selection, cfi, annotated: true });
}
const updatedConfig = updateBooknotes(bookKey, annotations);
@@ -529,286 +570,19 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
eventDispatcher.dispatch('tts-speak', { bookKey, range: selection.range });
};
- // Import type for ReplacementConfig
- type ReplacementConfig = {
- replacementText: string;
- caseSensitive: boolean;
- scope: 'once' | 'book' | 'library';
- };
-
- // Helper to check if selected text is a whole word (has word boundaries on both sides)
- // Updated to be more lenient: allows phrases and lines, only prevents partial word matches
- const isWholeWord = (range: Range, selectedText: string): boolean => {
- try {
- if (!selectedText || selectedText.trim().length === 0) return false;
-
- // Verify the selection contains word characters
- const hasWordCharInSelection = /[a-zA-Z0-9_]/.test(selectedText);
- if (!hasWordCharInSelection) {
- return false;
- }
-
- // If the selection contains spaces, punctuation, or multiple words, it's a phrase
- // Phrases (including lines with quotes) are always allowed for single-instance replacements
- const hasSpaces = /\s/.test(selectedText);
- const hasPunctuation = /[^\w\s]/.test(selectedText);
- const isPhrase = hasSpaces || hasPunctuation;
-
- // Also allow selections that start or end with punctuation (e.g., "'tis", "off;", "look,")
- // These are valid selections where the user intentionally includes punctuation
- const startsWithPunctuation = /^[^\w\s]/.test(selectedText);
- const endsWithPunctuation = /[^\w\s]$/.test(selectedText);
- const hasBoundaryPunctuation = startsWithPunctuation || endsWithPunctuation;
-
- if (isPhrase || hasBoundaryPunctuation) {
- // For phrases or selections with boundary punctuation, we allow them
- // The only thing we want to prevent is selecting "and" inside "England"
- return true;
- }
-
- // For single words, check boundaries to prevent partial word matches
- // Get characters immediately before and after the selection
- let charBefore = '';
- let charAfter = '';
-
- try {
- // Get character before
- const startNode = range.startContainer;
- if (startNode.nodeType === Node.TEXT_NODE && range.startOffset > 0) {
- const textNode = startNode as Text;
- charBefore = textNode.textContent?.charAt(range.startOffset - 1) || '';
- } else if (startNode.nodeType === Node.TEXT_NODE && range.startOffset === 0) {
- // Check previous sibling text node
- let prevSibling = startNode.previousSibling;
- while (prevSibling && prevSibling.nodeType !== Node.TEXT_NODE) {
- prevSibling = prevSibling.previousSibling;
- }
- if (prevSibling && prevSibling.nodeType === Node.TEXT_NODE) {
- const prevText = (prevSibling as Text).textContent || '';
- charBefore = prevText.charAt(prevText.length - 1);
- }
- }
-
- // Get character after
- const endNode = range.endContainer;
- if (endNode.nodeType === Node.TEXT_NODE) {
- const textNode = endNode as Text;
- const textContent = textNode.textContent || '';
- if (range.endOffset < textContent.length) {
- charAfter = textContent.charAt(range.endOffset);
- } else {
- // Check next sibling text node
- let nextSibling = textNode.nextSibling;
- while (nextSibling && nextSibling.nodeType !== Node.TEXT_NODE) {
- nextSibling = nextSibling.nextSibling;
- }
- if (nextSibling && nextSibling.nodeType === Node.TEXT_NODE) {
- const nextText = (nextSibling as Text).textContent || '';
- charAfter = nextText.charAt(0);
- }
- }
- }
- } catch (e) {
- // If we can't determine boundaries for a single word, be lenient
- // This handles edge cases with complex HTML
- console.warn('[isWholeWord] Error checking boundaries:', e);
- return true; // Allow if we can't verify (better to allow than reject valid selections)
- }
-
- // Word characters are: letters, digits, and underscore [a-zA-Z0-9_]
- const isWordChar = (char: string) => /[a-zA-Z0-9_]/.test(char);
-
- // Check boundaries for single words
- // Empty means we're at start/end of text (valid boundary)
- const hasBoundaryBefore = !charBefore || !isWordChar(charBefore);
- const hasBoundaryAfter = !charAfter || !isWordChar(charAfter);
-
- const isValid = hasBoundaryBefore && hasBoundaryAfter;
-
- if (!isValid) {
- console.log('[isWholeWord] Not a whole word:', {
- selectedText,
- charBefore: charBefore || '(start)',
- charAfter: charAfter || '(end)',
- hasBoundaryBefore,
- hasBoundaryAfter,
- });
- }
-
- return isValid;
- } catch (e) {
- console.warn('Failed to check whole word:', e);
- // On error, be lenient - allow selections with word characters
- // This prevents false rejections for complex selections (quotes, multi-node, etc.)
- return /[a-zA-Z0-9_]/.test(selectedText);
- }
- };
-
- // Helper to count which occurrence of a pattern was selected (using whole-word matching)
- const getOccurrenceIndex = (range: Range, pattern: string): number => {
- try {
- const doc = range.startContainer.ownerDocument;
- if (!doc || !doc.body) return 0;
-
- // Create a range from start of body to start of selection
- const beforeRange = doc.createRange();
- beforeRange.setStart(doc.body, 0);
- beforeRange.setEnd(range.startContainer, range.startOffset);
-
- // Get text before selection and count occurrences using whole-word matching
- const textBefore = beforeRange.toString();
- // Escape pattern and add word boundaries for whole-word matching
- const escapedPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
- const wholeWordPattern = `\\b${escapedPattern}\\b`;
- const regex = new RegExp(wholeWordPattern, 'g');
- const matches = textBefore.match(regex);
-
- return matches ? matches.length : 0;
- } catch (e) {
- console.warn('Failed to get occurrence index:', e);
- return 0;
- }
- };
-
- const handleReplacementConfirm = async (config: ReplacementConfig) => {
+ const handleShowProofreadOptions = () => {
if (!selection || !selection.text) return;
+ setShowAnnotPopup(false);
+ setShowProofreadPopup(true);
- const { replacementText, caseSensitive, scope } = config;
-
- console.log('Replacement confirmed:', {
- originalText: selection.text,
- replacementText,
- caseSensitive,
- scope,
- });
-
- try {
- if (scope === 'once') {
- // For single-instance: direct DOM modification + persistent rule
- const range = selection.range;
- if (range) {
- // Validate that the selection is a whole word
- // Single-instance replacements only work on whole words to prevent
- // replacing substrings inside larger words (e.g., "and" in "England")
- const isValidWholeWord = isWholeWord(range, selection.text);
-
- if (!isValidWholeWord) {
- eventDispatcher.dispatch('toast', {
- type: 'warning',
- message: `Cannot replace "${selection.text}" - please select a complete word. Partial word selections (like "and" in "England" or "errand") are not supported.`,
- timeout: 5000,
- });
- return;
- }
-
- // Get which occurrence this is BEFORE modifying the DOM
- // Use whole-word matching to count occurrences correctly
- const occurrenceIndex = getOccurrenceIndex(range, selection.text);
- const sectionHref = progress?.sectionHref;
-
- // Directly modify DOM for immediate effect
- // Note: createTextNode automatically escapes HTML entities, so angle brackets will be preserved
- range.deleteContents();
- const textNode = document.createTextNode(replacementText);
- range.insertNode(textNode);
-
- // Create rule with occurrence tracking for persistence
- await addReplacementRule(
- envConfig,
- bookKey,
- {
- pattern: selection.text,
- replacement: replacementText,
- isRegex: false,
- enabled: true,
- caseSensitive,
- singleInstance: true,
- sectionHref,
- occurrenceIndex,
- },
- 'single',
- );
-
- eventDispatcher.dispatch('toast', {
- type: 'success',
- message: 'Replacement applied! Will persist on refresh.',
- timeout: 3000,
- });
-
- setShowReplacementOptions(false);
- handleDismissPopupAndSelection();
- }
- } else {
- // For book-wide and global: use the transformer approach
- const backendScope = scope === 'book' ? 'book' : 'global';
- const range = selection.range;
- const isValidWholeWord = range ? isWholeWord(range, selection.text) : false;
- if (!isValidWholeWord) {
- eventDispatcher.dispatch('toast', {
- type: 'warning',
- message: `Cannot replace "${selection.text}" - please select a complete word. Partial word selections (like "and" in "England" or "errand") are not supported.`,
- timeout: 5000,
- });
- return;
- }
- await addReplacementRule(
- envConfig,
- bookKey,
- {
- pattern: selection.text,
- replacement: replacementText,
- isRegex: false,
- enabled: true,
- caseSensitive,
- singleInstance: false,
- wholeWord: true,
- },
- backendScope as 'book' | 'global',
- );
-
- const scopeLabels = {
- book: 'this book',
- library: 'your library',
- };
-
- eventDispatcher.dispatch('toast', {
- type: 'success',
- message: `Replacement applied to ${scopeLabels[scope]}! Reloading...`,
- timeout: 3000,
- });
-
- setShowReplacementOptions(false);
- handleDismissPopupAndSelection();
-
- // Reload the book view to apply the replacement
- const { recreateViewer } = useReaderStore.getState();
- await recreateViewer(envConfig, bookKey);
- }
- } catch (error) {
- console.error('Failed to apply replacement:', error);
- eventDispatcher.dispatch('toast', {
- type: 'error',
- message: 'Failed to apply replacement. Please try again.',
- timeout: 3000,
- });
- }
- };
-
- const handleShowReplacementOptions = () => {
- if (!selection || !selection.text) {
- return;
- }
-
- if (isWordLimitExceeded(selection.text)) {
+ if (getWordCount(selection.text) > 30) {
eventDispatcher.dispatch('toast', {
type: 'warning',
- message: 'Word limit exceeded. Please select 30 words or fewer.',
+ message: _('Word limit of 30 words exceeded.'),
timeout: 3000,
});
return;
}
-
- setShowReplacementOptions(!showReplacementOptions);
};
// Keyboard shortcuts: trigger actions only if there's an active selection and popup hidden
@@ -827,7 +601,7 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
handleSearch();
},
onCopySelection: () => {
- handleCopy(false);
+ handleCopy(false, false);
},
onTranslateSelection: () => {
handleTranslation();
@@ -961,11 +735,10 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
disabled: bookData.book?.format === 'PDF',
},
{
- tooltipText: 'Text Replacement',
- Icon: MdBuildCircle,
- onClick: handleShowReplacementOptions,
+ tooltipText: _('Proofread'),
+ Icon: IoIosBuild,
+ onClick: handleShowProofreadOptions,
disabled: bookData.book?.format !== 'EPUB',
- visible: false,
},
];
@@ -1019,20 +792,15 @@ const Annotator: React.FC<{ bookKey: string }> = ({ bookKey }) => {
onDismiss={handleDismissPopupAndSelection}
/>
)}
- {showReplacementOptions && trianglePosition && annotPopupPosition && (
- setShowReplacementOptions(false)}
+ {showProofreadPopup && trianglePosition && proofreadPopupPosition && selection && (
+ = ({
return (
void;
+ onDismiss: () => void;
+}
+
+const ProofreadPopup: React.FC = ({
+ bookKey,
+ selection,
+ position,
+ trianglePosition,
+ popupWidth,
+ popupHeight,
+ onConfirm,
+ onDismiss,
+}) => {
+ const _ = useTranslation();
+ const { envConfig } = useEnv();
+ const { getProgress, getView, recreateViewer } = useReaderStore();
+ const { addRule } = useProofreadStore();
+ const progress = getProgress(bookKey)!;
+
+ const [replacementText, setReplacementText] = useState('');
+ const [caseSensitive, setCaseSensitive] = useState(true);
+ const [scope, setScope] = useState('selection');
+
+ const inputRef = useRef(null);
+ useAutoFocus({ ref: inputRef });
+
+ const handleScopeChange = (event: React.ChangeEvent) => {
+ setScope(event.target.value as ProofreadScope);
+ };
+
+ const handleApply = async () => {
+ if (!selection) return;
+
+ const range = selection?.range;
+
+ if (range) {
+ const isValidWholeWord = isWholeWord(range, selection?.text || '');
+
+ if (!isValidWholeWord) {
+ eventDispatcher.dispatch('toast', {
+ type: 'warning',
+ message: `Cannot replace "${selection.text}" - please select a complete word. Partial word selections (like "and" in "England" or "errand") are not supported.`,
+ timeout: 5000,
+ });
+ return;
+ }
+
+ if (scope === 'selection') {
+ range.deleteContents();
+ const textNode = document.createTextNode(replacementText);
+ range.insertNode(textNode);
+ }
+
+ const options = {
+ scope,
+ pattern: selection.text,
+ replacement: replacementText.trim(),
+ cfi: selection.cfi,
+ sectionHref: progress?.sectionHref,
+ isRegex: false,
+ enabled: true,
+ caseSensitive,
+ wholeWord: true,
+ };
+ onConfirm?.(options);
+
+ await addRule(envConfig, bookKey, options);
+
+ onDismiss();
+
+ if (scope !== 'selection') {
+ if (getView(bookKey)) {
+ recreateViewer(envConfig, bookKey);
+ }
+ }
+ }
+ };
+
+ const scopeOptions = [
+ { value: 'selection', label: _('Current selection') },
+ { value: 'book', label: _('All occurrences in this book') },
+ { value: 'library', label: _('All occurrences in your library') },
+ ];
+
+ return (
+
+
+
+
+ {_('Selected text:')}
+
+ "{selection?.text || ''}"
+
+
+
+
+
+ {_('Replace with:')}
+
+
+ {_('Apply')}
+
+
+
+
+
+ {_('Case sensitive:')}
+
+
+
+
+
+ {_('Scope:')}
+
+
+
+
= ({
- style,
- isVertical,
- selectedText,
- onConfirm,
- onClose,
-}) => {
- const menuRef = useRef(null);
- const inputRef = useRef(null);
-
- const [replacementText, setReplacementText] = useState('');
- const [caseSensitive, setCaseSensitive] = useState(true);
- const [selectedScope, setSelectedScope] = useState<'once' | 'book' | 'library' | null>(null);
- const [showConfirmation, setShowConfirmation] = useState(false);
- const [adjustedStyle, setAdjustedStyle] = useState(null);
- const [isPositioned, setIsPositioned] = useState(false);
- const hasAdjusted = useRef(false);
-
- // Adjust position to stay within viewport - only once on initial render
- useEffect(() => {
- // Only adjust once to prevent jumping when other UI elements appear
- if (menuRef.current && !hasAdjusted.current) {
- // Use requestAnimationFrame to ensure the element is rendered before measuring
- requestAnimationFrame(() => {
- if (menuRef.current) {
- const rect = menuRef.current.getBoundingClientRect();
- const viewportHeight = window.innerHeight;
- const viewportWidth = window.innerWidth;
- const padding = 10;
-
- const newStyle = { ...style };
-
- // Check if popup extends beyond bottom of viewport
- if (rect.bottom > viewportHeight - padding) {
- const currentTop = parseFloat(String(style.top)) || 0;
- // Move popup above the selection instead
- newStyle.top = `${Math.max(padding, currentTop - rect.height - 40)}px`;
- }
-
- // Check if popup extends beyond right of viewport
- if (rect.right > viewportWidth - padding) {
- newStyle.left = `${Math.max(padding, viewportWidth - rect.width - padding)}px`;
- }
-
- // Check if popup extends beyond left of viewport
- if (rect.left < padding) {
- newStyle.left = `${padding}px`;
- }
-
- setAdjustedStyle(newStyle);
- hasAdjusted.current = true;
- setIsPositioned(true);
- }
- });
- }
- }, [style]);
-
- useEffect(() => {
- const handleClickOutside = (event: MouseEvent) => {
- if (menuRef.current && !menuRef.current.contains(event.target as Node)) {
- onClose();
- }
- };
-
- document.addEventListener('mousedown', handleClickOutside);
- return () => {
- document.removeEventListener('mousedown', handleClickOutside);
- };
- }, [onClose]);
-
- // Focus input on mount
- useEffect(() => {
- if (inputRef.current) {
- inputRef.current.focus();
- }
- }, []);
-
- const handleScopeClick = (scope: 'once' | 'book' | 'library') => {
- if (!replacementText.trim()) {
- // Show error if no replacement text
- return;
- }
- setSelectedScope(scope);
- setShowConfirmation(true);
- };
-
- const handleConfirm = () => {
- if (selectedScope && replacementText.trim()) {
- onConfirm({
- replacementText: replacementText.trim(),
- caseSensitive,
- scope: selectedScope,
- });
- }
- };
-
- const handleCancelConfirmation = () => {
- setShowConfirmation(false);
- setSelectedScope(null);
- };
-
- const handleCancel = () => {
- onClose();
- };
-
- const getScopeLabel = (scope: 'once' | 'book' | 'library' | null) => {
- switch (scope) {
- case 'once':
- return 'this instance';
- case 'book':
- return 'all instances in this book';
- case 'library':
- return 'all instances in your library';
- default:
- return '';
- }
- };
-
- // Secondary confirmation dialog
- if (showConfirmation) {
- return (
-
-
-
Confirm Replacement
-
- Replace: "{selectedText}"
-
-
- With: "{replacementText}"
-
-
- Scope: {getScopeLabel(selectedScope)}
-
-
- Case sensitive: {caseSensitive ? 'Yes' : 'No'}
-
-
-
-
-
- Back
-
-
- Confirm
-
-
-
- {/* Selected text preview */}
-
- Selected:
-
- "{selectedText.length > 50 ? selectedText.substring(0, 50) + '...' : selectedText}
- "
-
-
-
- {/* Replacement text input */}
-
-
- Replace with:
-
-
-
- {/* Case sensitivity checkbox */}
-
- Case Sensitive
-
-
- {/* Scope buttons */}
-
- handleScopeClick('once')}
- disabled={!replacementText.trim()}
- className={clsx(
- 'whitespace-nowrap rounded-md px-3 py-2 text-left text-sm text-white transition-colors',
- replacementText.trim() ? 'hover:bg-base-content/10' : 'cursor-not-allowed opacity-50',
- )}
- >
- Fix this once
-
- handleScopeClick('book')}
- disabled={!replacementText.trim()}
- className={clsx(
- 'whitespace-nowrap rounded-md px-3 py-2 text-left text-sm text-white transition-colors',
- replacementText.trim() ? 'hover:bg-base-content/10' : 'cursor-not-allowed opacity-50',
- )}
- >
- Fix in this book
-
- handleScopeClick('library')}
- disabled={!replacementText.trim()}
- className={clsx(
- 'whitespace-nowrap rounded-md px-3 py-2 text-left text-sm text-white transition-colors',
- replacementText.trim() ? 'hover:bg-base-content/10' : 'cursor-not-allowed opacity-50',
- )}
- >
- Fix in library
-
-
-
- {/* Cancel button */}
-
- Cancel
-
-
= ({ menuClassName, setIsDropdownOpen })
setKOSyncSettingsWindowVisible(true);
setIsDropdownOpen?.(false);
};
- const showReplacementRulesWindow = () => {
- setReplacementRulesWindowVisible(true);
+ const showProofreadRulesWindow = () => {
+ setProofreadRulesVisibility(true);
setIsDropdownOpen?.(false);
};
const handlePullKOSync = () => {
@@ -145,7 +145,6 @@ const BookMenu: React.FC = ({ menuClassName, setIsDropdownOpen })
))}
= ({ menuClassName, setIsDropdownOpen })
)}
{
@@ -65,7 +71,13 @@ export const useTextSelector = (
setTimeout(async () => {
if (!isTextSelected.current) return;
sel.addRange(range);
- setSelection({ key: bookKey, text: await getAnnotationText(range), range, index });
+ setSelection({
+ key: bookKey,
+ text: await getAnnotationText(range),
+ cfi: view?.getCFI(index, range),
+ range,
+ index,
+ });
}, 30);
}, 30);
};
diff --git a/apps/readest-app/src/services/transformers/index.ts b/apps/readest-app/src/services/transformers/index.ts
index 6740c976..0967f708 100644
--- a/apps/readest-app/src/services/transformers/index.ts
+++ b/apps/readest-app/src/services/transformers/index.ts
@@ -6,7 +6,7 @@ import { whitespaceTransformer } from './whitespace';
import { sanitizerTransformer } from './sanitizer';
import { simpleccTransformer } from './simplecc';
import { styleTransformer } from './style';
-import { replacementTransformer } from './replacement';
+import { proofreadTransformer } from './proofread';
export const availableTransformers: Transformer[] = [
punctuationTransformer,
@@ -16,6 +16,6 @@ export const availableTransformers: Transformer[] = [
whitespaceTransformer,
sanitizerTransformer,
simpleccTransformer,
- replacementTransformer,
+ proofreadTransformer,
// Add more transformers here
];
diff --git a/apps/readest-app/src/services/transformers/proofread.ts b/apps/readest-app/src/services/transformers/proofread.ts
new file mode 100644
index 00000000..e6be78fe
--- /dev/null
+++ b/apps/readest-app/src/services/transformers/proofread.ts
@@ -0,0 +1,225 @@
+import * as CFI from 'foliate-js/epubcfi.js';
+import type { Transformer } from './types';
+import { ProofreadRule } from '@/types/book';
+import { useSettingsStore } from '@/store/settingsStore';
+
+interface NormalizedPattern {
+ source: string;
+ flags: string;
+}
+
+const isUnicodeWordChar = (char: string): boolean => /[\p{L}\p{N}_]/u.test(char || '');
+const hasUnicodeChars = (text: string): boolean => /[^\x00-\x7F]/.test(text);
+
+function normalizePattern(
+ pattern: string,
+ isRegex: boolean,
+ caseSensitive = true,
+): NormalizedPattern {
+ const hasUnicode = hasUnicodeChars(pattern);
+
+ let flags = hasUnicode ? 'ug' : 'g';
+ if (!caseSensitive) flags += 'i';
+
+ if (isRegex) {
+ const source = pattern.includes('\\b') || hasUnicode ? pattern : `\\b${pattern}\\b`;
+ return { source, flags };
+ }
+
+ const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+ if (hasUnicode) {
+ return { source: escaped, flags };
+ }
+
+ const startsWithPunctuation = /^[^\w\s]/.test(pattern);
+ const endsWithPunctuation = /[^\w\s]$/.test(pattern);
+
+ if (startsWithPunctuation || endsWithPunctuation) {
+ const wordMatch = pattern.match(/[\w]+/);
+ if (!wordMatch) return { source: escaped, flags };
+
+ const wordPart = wordMatch[0];
+ const wordStart = pattern.indexOf(wordPart);
+ const wordEnd = wordStart + wordPart.length;
+ const wordEscaped = wordPart.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+ const beforeWord = escaped.substring(0, wordStart);
+ const afterWord = escaped.substring(wordEnd);
+ return { source: `${beforeWord}\\b${wordEscaped}\\b${afterWord}`, flags };
+ }
+
+ return { source: `\\b${escaped}\\b`, flags };
+}
+
+function isValidMatch(text: string, match: RegExpExecArray, rule: ProofreadRule): boolean {
+ if (!rule.isRegex) {
+ const isCaseSensitive = rule.caseSensitive !== false;
+ const isExactMatch = isCaseSensitive
+ ? match[0] === rule.pattern
+ : match[0].toLowerCase() === rule.pattern.toLowerCase();
+ if (!isExactMatch) return false;
+ }
+
+ if (hasUnicodeChars(rule.pattern)) {
+ const charBefore = text[match.index - 1] ?? '';
+ const charAfter = text[match.index + match[0].length] ?? '';
+ if (isUnicodeWordChar(charBefore) || isUnicodeWordChar(charAfter)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+function applyReplacementMulti(
+ textNodes: Text[],
+ rule: ProofreadRule & { normalizedPattern: NormalizedPattern },
+): void {
+ let regex: RegExp;
+ try {
+ regex = new RegExp(rule.normalizedPattern.source, rule.normalizedPattern.flags);
+ } catch {
+ return;
+ }
+
+ for (const textNode of textNodes) {
+ if (!textNode.textContent) continue;
+
+ let text = textNode.textContent;
+ const matches: Array<{ index: number; length: number }> = [];
+ let match: RegExpExecArray | null;
+
+ while ((match = regex.exec(text)) !== null) {
+ if (!isValidMatch(text, match, rule)) continue;
+ matches.push({ index: match.index, length: match[0].length });
+ }
+
+ if (matches.length === 0) continue;
+
+ for (let i = matches.length - 1; i >= 0; i--) {
+ const m = matches[i]!;
+ text = text.slice(0, m.index) + rule.replacement + text.slice(m.index + m.length);
+ }
+
+ textNode.textContent = text;
+ }
+}
+
+function applyReplacementSingle(
+ doc: Document,
+ rule: ProofreadRule & { normalizedPattern: NormalizedPattern },
+): void {
+ let regex: RegExp;
+ try {
+ regex = new RegExp(rule.normalizedPattern.source, rule.normalizedPattern.flags);
+ } catch {
+ return;
+ }
+
+ const parts = CFI.parse(rule.cfi);
+ if (parts.parent) {
+ parts.parent.shift();
+ const range = CFI.toRange(doc, parts) as Range;
+ if (range) {
+ const startContainer = range.startContainer;
+ const endContainer = range.endContainer;
+ if (startContainer === endContainer && startContainer.nodeType === Node.TEXT_NODE) {
+ const textNode = startContainer as Text;
+ const text = textNode.textContent || '';
+ const startOffset = range.startOffset;
+ const endOffset = range.endOffset;
+
+ // Add 32-char tolerance buffer around the selection
+ const bufferSize = 32;
+ const bufferStart = Math.max(0, startOffset - bufferSize);
+ const bufferEnd = Math.min(text.length, endOffset + bufferSize);
+
+ const bufferedText = text.slice(bufferStart, bufferEnd);
+ const selectedText = text.slice(startOffset, endOffset);
+
+ const match = regex.exec(bufferedText);
+ if (match && isValidMatch(selectedText, match, rule)) {
+ const matchStartInBuffer = match.index;
+ const matchStartInText = bufferStart + matchStartInBuffer;
+ const matchEnd = matchStartInText + match[0].length;
+
+ if (matchEnd >= startOffset - bufferSize && matchStartInText <= endOffset + bufferSize) {
+ const newText =
+ text.slice(0, matchStartInText) + rule.replacement + text.slice(matchEnd);
+ textNode.textContent = newText;
+ return;
+ }
+ }
+ }
+ }
+ }
+}
+
+function getTextNodes(doc: Document): Text[] {
+ const walker = document.createTreeWalker(doc.body || doc.documentElement, NodeFilter.SHOW_TEXT, {
+ acceptNode: (node) => {
+ const parent = node.parentElement;
+ if (parent?.tagName === 'SCRIPT' || parent?.tagName === 'STYLE') {
+ return NodeFilter.FILTER_REJECT;
+ }
+ return node.textContent?.trim() ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+ },
+ });
+
+ const textNodes: Text[] = [];
+ let node: Node | null;
+ while ((node = walker.nextNode())) {
+ textNodes.push(node as Text);
+ }
+ return textNodes;
+}
+
+export const proofreadTransformer: Transformer = {
+ name: 'proofread',
+
+ transform: async (ctx) => {
+ const globalRules = useSettingsStore.getState().settings?.globalViewSettings?.proofreadRules;
+ const bookRules = ctx.viewSettings.proofreadRules;
+ const merged = [...(globalRules ?? []), ...(bookRules ?? [])].sort(
+ (a, b) => (a.order ?? 0) - (b.order ?? 0),
+ );
+ if (!merged.length) return ctx.content;
+
+ const processed = merged
+ .filter((r) => r.enabled && r.pattern.trim())
+ .map((r) => ({
+ ...r,
+ normalizedPattern: normalizePattern(r.pattern, r.isRegex, r.caseSensitive !== false),
+ }));
+
+ if (!processed.length) return ctx.content;
+
+ const parser = new DOMParser();
+ const doc = parser.parseFromString(ctx.content, 'text/html');
+ const textNodes = getTextNodes(doc);
+
+ const byScope = {
+ selection: processed.filter((r) => r.scope === 'selection'),
+ book: processed.filter((r) => r.scope === 'book'),
+ library: processed.filter((r) => r.scope === 'library'),
+ };
+
+ const ordered = [...byScope.selection, ...byScope.book, ...byScope.library];
+
+ for (const rule of ordered) {
+ if (rule.scope === 'selection') {
+ const ruleBase = rule.sectionHref?.split('#')[0];
+ const ctxBase = ctx.sectionHref?.split('#')[0];
+ if (ctxBase !== ruleBase) continue;
+ }
+ if (rule.scope === 'selection') {
+ applyReplacementSingle(doc, rule);
+ } else {
+ applyReplacementMulti(textNodes, rule);
+ }
+ }
+
+ return new XMLSerializer().serializeToString(doc);
+ },
+};
diff --git a/apps/readest-app/src/services/transformers/replacement.ts b/apps/readest-app/src/services/transformers/replacement.ts
deleted file mode 100644
index 6312e9af..00000000
--- a/apps/readest-app/src/services/transformers/replacement.ts
+++ /dev/null
@@ -1,704 +0,0 @@
-import type { Transformer } from './types';
-import { ReplacementRule, ViewSettings } from '@/types/book';
-import { SystemSettings } from '@/types/settings';
-import { EnvConfigType } from '@/services/environment';
-import { useReaderStore } from '@/store/readerStore';
-import { useSettingsStore } from '@/store/settingsStore';
-import { useBookDataStore } from '@/store/bookDataStore';
-import { uniqueId } from '@/utils/misc';
-
-// Whole-word enforcement for ALL rules (literal OR regex)
-// Case-sensitive, with Unicode-aware boundaries for non-ASCII patterns
-interface NormalizedPattern {
- source: string;
- flags: string;
-}
-
-// Check if a character is a Unicode word character (letter, number, or underscore)
-function isUnicodeWordChar(char: string): boolean {
- if (!char) return false;
- return /[\p{L}\p{N}_]/u.test(char);
-}
-
-function normalizePattern(
- pattern: string,
- isRegex: boolean,
- caseSensitive = true,
-): NormalizedPattern {
- const hasUnicode = /[^\x00-\x7F]/.test(pattern);
-
- let flags = '';
- if (hasUnicode) flags += 'u';
- flags += 'g';
- if (!caseSensitive) flags += 'i';
-
- if (isRegex) {
- // Do NOT escape regex patterns; just add boundaries if missing
- if (pattern.includes('\\b')) {
- return { source: pattern, flags };
- }
- // For regex patterns, use \b for ASCII (works well)
- // For Unicode, we'll rely on manual boundary checking in the matching functions
- const source = hasUnicode
- ? pattern // Don't add boundaries for Unicode regex - will check manually
- : `\\b${pattern}\\b`;
- return { source, flags };
- }
-
- // Escape literals
- const escaped = pattern.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&');
-
- // Check if pattern has punctuation at start or end
- const startsWithPunctuation = /^[^\w\s]/.test(pattern);
- const endsWithPunctuation = /[^\w\s]$/.test(pattern);
- const hasBoundaryPunctuation = startsWithPunctuation || endsWithPunctuation;
-
- // For ASCII patterns with boundary punctuation, add boundaries only around the word part
- // For patterns without boundary punctuation, add boundaries around the whole pattern
- // For Unicode patterns, we'll check boundaries manually
- let source: string;
- if (hasUnicode) {
- // Don't add boundaries for Unicode - will check manually
- source = escaped;
- } else if (hasBoundaryPunctuation) {
- // For patterns like "scholar;" or "'tis", find the word part and add boundaries only around it
- const wordMatch = pattern.match(/[\w]+/);
- if (!wordMatch || !wordMatch[0]) {
- // No word characters found, just use escaped pattern without boundaries
- source = escaped;
- } else {
- const wordPart = wordMatch[0];
- const wordStart = pattern.indexOf(wordPart);
- const wordEnd = wordStart + wordPart.length;
-
- // Escape the word part separately
- const wordEscaped = wordPart.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&');
-
- // Build the pattern: [before punctuation][word boundary][word][word boundary][after punctuation]
- const beforeWord = escaped.substring(0, wordStart);
- const afterWord = escaped.substring(wordEnd);
- source = `${beforeWord}\\b${wordEscaped}\\b${afterWord}`;
- }
- } else {
- // No boundary punctuation - add boundaries around the whole pattern
- source = `\\b${escaped}\\b`;
- }
-
- return { source, flags };
-}
-
-// Apply multi-replacement to text nodes
-function applyRuleToTextNodesMulti(
- textNodes: Text[],
- rule: ReplacementRule & { normalizedPattern: NormalizedPattern },
-): void {
- let regex: RegExp;
- try {
- regex = new RegExp(rule.normalizedPattern.source, rule.normalizedPattern.flags || 'g');
- } catch (_e) {
- return; // Invalid regex
- }
-
- for (const textNode of textNodes) {
- if (!textNode.textContent) continue;
-
- let text = textNode.textContent;
- const matches: { index: number; length: number }[] = [];
-
- let m;
- while ((m = regex.exec(text)) !== null) {
- const start = m.index;
-
- // For literal (non-regex) rules, ensure exact match
- if (!rule.isRegex) {
- const match = m[0];
- const pattern = rule.pattern;
- const isCaseSensitive = rule.caseSensitive !== false;
- const isMatch = isCaseSensitive
- ? match === pattern
- : match.toLowerCase() === pattern.toLowerCase();
- if (!isMatch) continue;
- }
-
- // Manual whole-word boundary check for Unicode patterns
- const hasUnicode = /[^\x00-\x7F]/.test(rule.pattern);
- if (hasUnicode) {
- const charBefore = text[start - 1] ?? '';
- const charAfter = text[start + m[0].length] ?? '';
- if (isUnicodeWordChar(charBefore) || isUnicodeWordChar(charAfter)) {
- continue;
- }
- }
-
- matches.push({ index: start, length: m[0].length });
- }
-
- // Apply replacements in reverse order to maintain indices
- for (let i = matches.length - 1; i >= 0; i--) {
- const match = matches[i];
- if (!match) continue;
- const { index, length } = match;
- const end = index + length;
-
- text = text.slice(0, index) + rule.replacement + text.slice(end);
- }
-
- // Update the text node with replaced content
- if (matches.length > 0) {
- textNode.textContent = text;
- }
- }
-}
-
-// Apply single-instance replacement to text nodes
-function applyRuleToTextNodesSingle(
- textNodes: Text[],
- rule: ReplacementRule & { normalizedPattern: NormalizedPattern },
-): void {
- let regex: RegExp;
- try {
- regex = new RegExp(rule.normalizedPattern.source, rule.normalizedPattern.flags || 'g');
- } catch (_e) {
- return;
- }
-
- // Collect all matches across all text nodes
- const allMatches: { nodeIndex: number; matchIndex: number; length: number }[] = [];
-
- for (let nodeIdx = 0; nodeIdx < textNodes.length; nodeIdx++) {
- const textNode = textNodes[nodeIdx];
- if (!textNode || !textNode.textContent) continue;
-
- const text = textNode.textContent;
- let m;
- while ((m = regex.exec(text)) !== null) {
- const start = m.index;
-
- // Case sensitive check for single-instance
- if (!rule.isRegex && m[0] !== rule.pattern) continue;
-
- // Unicode whole-word check
- const hasUnicode = /[^\x00-\x7F]/.test(rule.pattern);
- if (hasUnicode) {
- const charBefore = text[start - 1] ?? '';
- const charAfter = text[start + m[0].length] ?? '';
- if (isUnicodeWordChar(charBefore) || isUnicodeWordChar(charAfter)) {
- continue;
- }
- }
-
- allMatches.push({ nodeIndex: nodeIdx, matchIndex: start, length: m[0].length });
- }
- }
-
- // Apply replacement to the target occurrence
- const targetIndex = rule.occurrenceIndex ?? 0;
- const target = allMatches[targetIndex];
- if (!target) return;
-
- const textNode = textNodes[target.nodeIndex];
- if (!textNode || !textNode.textContent) return;
-
- const text = textNode.textContent;
- const newText =
- text.slice(0, target.matchIndex) +
- rule.replacement +
- text.slice(target.matchIndex + target.length);
- textNode.textContent = newText;
-}
-
-// DOM-Based Transformer function
-export const replacementTransformer: Transformer = {
- name: 'replacement',
-
- transform: async (ctx) => {
- const globalRaw = useSettingsStore.getState().settings?.globalViewSettings?.replacementRules;
- const bookRaw = ctx.viewSettings.replacementRules;
-
- const merged = mergeReplacementRules(globalRaw, bookRaw);
- if (!merged || merged.length === 0) return ctx.content;
-
- const processed = merged
- .filter((r) => r.enabled && r.pattern.trim().length > 0)
- .map((r) => ({
- ...r,
- normalizedPattern: normalizePattern(r.pattern, r.isRegex, r.caseSensitive !== false),
- }));
-
- if (processed.length === 0) return ctx.content;
-
- // Parse HTML into DOM
- const parser = new DOMParser();
- const doc = parser.parseFromString(ctx.content, 'text/html');
-
- // Get all text nodes using TreeWalker
- const walker = document.createTreeWalker(
- doc.body || doc.documentElement,
- NodeFilter.SHOW_TEXT,
- {
- acceptNode: (node) => {
- const parent = node.parentElement;
- // Skip script and style tags
- if (parent && (parent.tagName === 'SCRIPT' || parent.tagName === 'STYLE')) {
- return NodeFilter.FILTER_REJECT;
- }
- // Only accept nodes with actual text content
- return node.textContent?.trim() ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
- },
- },
- );
-
- // Collect all text nodes
- const textNodes: Text[] = [];
- let currentNode: Node | null;
- while ((currentNode = walker.nextNode())) {
- textNodes.push(currentNode as Text);
- }
-
- // Separate rules by type
- const singleRules = processed.filter((r) => r.singleInstance);
- const bookRules = processed.filter((r) => !r.singleInstance && !r.global);
- const globalRules = processed.filter((r) => !r.singleInstance && r.global);
-
- const ordered = [...singleRules, ...bookRules, ...globalRules];
-
- // Apply replacements to text nodes
- for (const rule of ordered) {
- // Check section match for single-instance rules
- if (rule.singleInstance && rule.sectionHref) {
- const ruleBase = rule.sectionHref.split('#')[0];
- const ctxBase = ctx.sectionHref?.split('#')[0];
- if (ctxBase !== ruleBase) continue;
- }
-
- if (rule.singleInstance) {
- applyRuleToTextNodesSingle(textNodes, rule);
- } else {
- applyRuleToTextNodesMulti(textNodes, rule);
- }
- }
-
- // Serialize back to HTML
- const serializer = new XMLSerializer();
- return serializer.serializeToString(doc);
- },
-};
-
-// Rule management
-export type ReplacementRuleScope = 'single' | 'book' | 'global';
-
-export interface CreateReplacementRuleOptions {
- pattern: string;
- replacement: string;
- isRegex?: boolean;
- enabled?: boolean;
- caseSensitive?: boolean;
- order?: number;
- singleInstance?: boolean;
- sectionHref?: string;
- occurrenceIndex?: number;
- wholeWord?: boolean;
- global?: boolean;
-}
-
-export function createReplacementRule(opts: CreateReplacementRuleOptions): ReplacementRule {
- return {
- id: uniqueId(),
- pattern: opts.pattern,
- replacement: opts.replacement,
- isRegex: opts.isRegex ?? false,
- enabled: opts.enabled ?? true,
- caseSensitive: opts.caseSensitive ?? true,
- order: opts.order ?? 1000,
- singleInstance: opts.singleInstance ?? false,
- wholeWord: opts.wholeWord ?? true,
- sectionHref: opts.sectionHref,
- occurrenceIndex: opts.occurrenceIndex,
- global: opts.global ?? false,
- };
-}
-
-export function mergeReplacementRules(
- globalRules: ReplacementRule[] | undefined,
- bookRules: ReplacementRule[] | undefined,
-): ReplacementRule[] {
- const map = new Map();
-
- for (const g of globalRules ?? []) map.set(g.id, g);
- for (const b of bookRules ?? []) map.set(b.id, b);
-
- return [...map.values()].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
-}
-
-/**
- * Gets all active replacement rules for a book (merged global + book rules)
- */
-export function getMergedReplacementRules(bookKey: string): ReplacementRule[] {
- const { settings } = useSettingsStore.getState();
- const { getViewSettings } = useReaderStore.getState();
- const viewSettings = getViewSettings(bookKey);
-
- const globalRules = settings.globalViewSettings.replacementRules;
- const bookRules = viewSettings?.replacementRules;
-
- return mergeReplacementRules(globalRules, bookRules);
-}
-
-/**
- * Adds a replacement rule at the specified scope
- */
-export async function addReplacementRule(
- envConfig: EnvConfigType,
- bookKey: string,
- options: CreateReplacementRuleOptions,
- scope: ReplacementRuleScope,
-): Promise {
- const rule = createReplacementRule(options);
-
- switch (scope) {
- case 'single':
- // Single-instance replacement: persisted in book config for refresh persistence
- await addReplacementRuleToBook(envConfig, bookKey, rule, true);
- break;
- case 'book':
- // Apply to entire book (persisted in book config)
- await addReplacementRuleToBook(envConfig, bookKey, rule, true);
- break;
- case 'global':
- // Apply globally to all books
- await addReplacementRuleToGlobal(envConfig, rule);
- break;
- }
-
- return rule;
-}
-
-/**
- * Adds a rule to a specific book's viewSettings
- */
-async function addReplacementRuleToBook(
- envConfig: EnvConfigType,
- bookKey: string,
- rule: ReplacementRule,
- persist: boolean,
-): Promise {
- const { getViewSettings, setViewSettings } = useReaderStore.getState();
- const { getConfig, saveConfig } = useBookDataStore.getState();
- const { settings } = useSettingsStore.getState();
-
- const viewSettings = getViewSettings(bookKey);
- if (!viewSettings) {
- throw new Error(`No viewSettings found for book: ${bookKey}`);
- }
-
- // Get existing book rules
- const existingRules = viewSettings.replacementRules || [];
-
- if (rule.singleInstance) {
- // Single-instance rules: ALWAYS create new rule (each has unique ID)
- // Don't try to merge - after DOM modifications, occurrence indices shift
- // and we can't reliably detect duplicates
- existingRules.push(rule);
- } else {
- // Non-single-instance: check if same pattern exists to avoid duplicates
- const existingRule = existingRules.find(
- (r) => r.pattern === rule.pattern && r.isRegex === rule.isRegex && !r.singleInstance,
- );
-
- if (existingRule) {
- // Update existing rule
- existingRule.replacement = rule.replacement;
- existingRule.enabled = rule.enabled;
- existingRule.order = rule.order;
- } else {
- // Add new rule
- existingRules.push(rule);
- }
- }
-
- // Update viewSettings
- const updatedViewSettings: ViewSettings = {
- ...viewSettings,
- replacementRules: existingRules,
- };
-
- setViewSettings(bookKey, updatedViewSettings);
-
- // Persist if requested
- if (persist) {
- const config = getConfig(bookKey);
- if (config) {
- const updatedConfig = {
- ...config,
- viewSettings: updatedViewSettings,
- updatedAt: Date.now(),
- };
- await saveConfig(envConfig, bookKey, updatedConfig, settings);
- }
- }
-}
-
-/**
- * Adds a rule to global viewSettings
- */
-async function addReplacementRuleToGlobal(
- envConfig: EnvConfigType,
- rule: ReplacementRule,
-): Promise {
- const { settings, setSettings, saveSettings } = useSettingsStore.getState();
-
- const globalRules = settings.globalViewSettings.replacementRules || [];
-
- // Check if rule with same pattern already exists
- const existingRule = globalRules.find(
- (r) => r.pattern === rule.pattern && r.isRegex === rule.isRegex,
- );
-
- if (existingRule) {
- // Update existing rule
- existingRule.replacement = rule.replacement;
- existingRule.enabled = rule.enabled;
- existingRule.order = rule.order;
- } else {
- // Add new rule
- globalRules.push(rule);
- }
-
- // Update global settings
- const updatedSettings: SystemSettings = {
- ...settings,
- globalViewSettings: {
- ...settings.globalViewSettings,
- replacementRules: globalRules,
- },
- };
-
- setSettings(updatedSettings);
- await saveSettings(envConfig, updatedSettings);
-}
-
-/**
- * Removes a replacement rule by ID
- */
-export async function removeReplacementRule(
- envConfig: EnvConfigType,
- bookKey: string,
- ruleId: string,
- scope: ReplacementRuleScope,
-): Promise {
- switch (scope) {
- case 'single':
- // Single-instance rules are persisted in book config
- await removeReplacementRuleFromBook(envConfig, bookKey, ruleId, true);
- break;
- case 'book':
- // Book-wide rules are persisted in book config
- await removeReplacementRuleFromBook(envConfig, bookKey, ruleId, true);
- break;
- case 'global':
- await removeReplacementRuleFromGlobal(envConfig, ruleId);
- break;
- }
-}
-
-/**
- * Removes a rule from a book's viewSettings
- */
-async function removeReplacementRuleFromBook(
- envConfig: EnvConfigType,
- bookKey: string,
- ruleId: string,
- persist: boolean,
-): Promise {
- const { getViewSettings, setViewSettings } = useReaderStore.getState();
- const { getConfig, saveConfig } = useBookDataStore.getState();
- const { settings } = useSettingsStore.getState();
-
- const viewSettings = getViewSettings(bookKey);
- if (!viewSettings) {
- throw new Error(`No viewSettings found for book: ${bookKey}`);
- }
-
- const existingRules = viewSettings.replacementRules || [];
- const filteredRules = existingRules.filter((r) => r.id !== ruleId);
-
- const updatedViewSettings: ViewSettings = {
- ...viewSettings,
- replacementRules: filteredRules,
- };
-
- setViewSettings(bookKey, updatedViewSettings);
-
- if (persist) {
- const config = getConfig(bookKey);
- if (config) {
- const updatedConfig = {
- ...config,
- viewSettings: updatedViewSettings,
- updatedAt: Date.now(),
- };
- await saveConfig(envConfig, bookKey, updatedConfig, settings);
- }
- }
-}
-
-/**
- * Removes a rule from global viewSettings
- */
-async function removeReplacementRuleFromGlobal(
- envConfig: EnvConfigType,
- ruleId: string,
-): Promise {
- const { settings, setSettings, saveSettings } = useSettingsStore.getState();
-
- const globalRules = settings.globalViewSettings.replacementRules || [];
- const filteredRules = globalRules.filter((r) => r.id !== ruleId);
-
- const updatedSettings: SystemSettings = {
- ...settings,
- globalViewSettings: {
- ...settings.globalViewSettings,
- replacementRules: filteredRules,
- },
- };
-
- setSettings(updatedSettings);
- await saveSettings(envConfig, updatedSettings);
-}
-
-/**
- * Updates an existing replacement rule
- */
-export async function updateReplacementRule(
- envConfig: EnvConfigType,
- bookKey: string,
- ruleId: string,
- updates: Partial>,
- scope: ReplacementRuleScope,
-): Promise {
- switch (scope) {
- case 'single':
- // Single-instance rules are persisted in book config
- await updateReplacementRuleInBook(envConfig, bookKey, ruleId, updates, true);
- break;
- case 'book':
- // Book-wide rules are persisted in book config
- await updateReplacementRuleInBook(envConfig, bookKey, ruleId, updates, true);
- break;
- case 'global':
- await updateReplacementRuleInGlobal(envConfig, ruleId, updates);
- break;
- }
-}
-
-/**
- * Updates a rule in a book's viewSettings
- */
-async function updateReplacementRuleInBook(
- envConfig: EnvConfigType,
- bookKey: string,
- ruleId: string,
- updates: Partial>,
- persist: boolean,
-): Promise {
- const { getViewSettings, setViewSettings } = useReaderStore.getState();
- const { getConfig, saveConfig } = useBookDataStore.getState();
- const { settings } = useSettingsStore.getState();
-
- const viewSettings = getViewSettings(bookKey);
- if (!viewSettings) {
- throw new Error(`No viewSettings found for book: ${bookKey}`);
- }
-
- const existingRules = viewSettings.replacementRules || [];
- const updatedRules = existingRules.map((r) => (r.id === ruleId ? { ...r, ...updates } : r));
-
- const updatedViewSettings: ViewSettings = {
- ...viewSettings,
- replacementRules: updatedRules,
- };
-
- setViewSettings(bookKey, updatedViewSettings);
-
- if (persist) {
- const config = getConfig(bookKey);
- if (config) {
- const updatedConfig = {
- ...config,
- viewSettings: updatedViewSettings,
- updatedAt: Date.now(),
- };
- await saveConfig(envConfig, bookKey, updatedConfig, settings);
- }
- }
-}
-
-/**
- * Updates a rule in global viewSettings
- */
-async function updateReplacementRuleInGlobal(
- envConfig: EnvConfigType,
- ruleId: string,
- updates: Partial>,
-): Promise {
- const { settings, setSettings, saveSettings } = useSettingsStore.getState();
-
- const globalRules = settings.globalViewSettings.replacementRules || [];
- const updatedRules = globalRules.map((r) => (r.id === ruleId ? { ...r, ...updates } : r));
-
- const updatedSettings: SystemSettings = {
- ...settings,
- globalViewSettings: {
- ...settings.globalViewSettings,
- replacementRules: updatedRules,
- },
- };
-
- setSettings(updatedSettings);
- await saveSettings(envConfig, updatedSettings);
-}
-
-/**
- * Toggles a rule's enabled state
- */
-export async function toggleReplacementRule(
- envConfig: EnvConfigType,
- bookKey: string,
- ruleId: string,
- scope: ReplacementRuleScope,
-): Promise {
- const mergedRules = getMergedReplacementRules(bookKey);
- const rule = mergedRules.find((r) => r.id === ruleId);
-
- if (!rule) {
- throw new Error(`Rule not found: ${ruleId}`);
- }
-
- await updateReplacementRule(envConfig, bookKey, ruleId, { enabled: !rule.enabled }, scope);
-}
-
-/**
- * Validates a replacement rule pattern
- */
-export function validateReplacementRulePattern(
- pattern: string,
- isRegex: boolean,
-): { valid: boolean; error?: string } {
- if (!pattern || pattern.trim().length === 0) {
- return { valid: false, error: 'Pattern cannot be empty' };
- }
-
- if (isRegex) {
- try {
- new RegExp(pattern);
- return { valid: true };
- } catch (error) {
- return {
- valid: false,
- error: error instanceof Error ? error.message : 'Invalid regex pattern',
- };
- }
- }
-
- return { valid: true };
-}
diff --git a/apps/readest-app/src/services/transformers/types.ts b/apps/readest-app/src/services/transformers/types.ts
index 1d89239b..94bde888 100644
--- a/apps/readest-app/src/services/transformers/types.ts
+++ b/apps/readest-app/src/services/transformers/types.ts
@@ -8,9 +8,9 @@ export type TransformContext = {
width?: number;
height?: number;
content: string;
+ sectionHref?: string;
transformers: string[];
reversePunctuationTransform?: boolean;
- sectionHref?: string; // Section href for single-instance replacement tracking
};
export type Transformer = {
diff --git a/apps/readest-app/src/store/proofreadStore.ts b/apps/readest-app/src/store/proofreadStore.ts
new file mode 100644
index 00000000..67bdcb05
--- /dev/null
+++ b/apps/readest-app/src/store/proofreadStore.ts
@@ -0,0 +1,325 @@
+import { create } from 'zustand';
+import { ProofreadRule, ProofreadScope, ViewSettings } from '@/types/book';
+import { SystemSettings } from '@/types/settings';
+import { EnvConfigType } from '@/services/environment';
+import { useReaderStore } from '@/store/readerStore';
+import { useSettingsStore } from '@/store/settingsStore';
+import { useBookDataStore } from '@/store/bookDataStore';
+import { uniqueId } from '@/utils/misc';
+
+export interface CreateProofreadRuleOptions {
+ scope: ProofreadScope;
+ pattern: string;
+ replacement: string;
+ cfi?: string;
+ sectionHref?: string;
+ isRegex?: boolean;
+ enabled?: boolean;
+ caseSensitive?: boolean;
+ order?: number;
+ wholeWord?: boolean;
+}
+
+interface ProofreadStoreState {
+ getBookRules: (bookKey: string) => ProofreadRule[];
+ getGlobalRules: () => ProofreadRule[];
+ getMergedRules: (bookKey: string) => ProofreadRule[];
+
+ addRule: (
+ envConfig: EnvConfigType,
+ bookKey: string,
+ options: CreateProofreadRuleOptions,
+ ) => Promise;
+ updateRule: (
+ envConfig: EnvConfigType,
+ bookKey: string,
+ ruleId: string,
+ updates: Partial>,
+ ) => Promise;
+ removeRule: (
+ envConfig: EnvConfigType,
+ bookKey: string,
+ ruleId: string,
+ scope: ProofreadScope,
+ ) => Promise;
+ toggleRule: (envConfig: EnvConfigType, bookKey: string, ruleId: string) => Promise;
+}
+
+function createProofreadRule(opts: CreateProofreadRuleOptions): ProofreadRule {
+ return {
+ id: uniqueId(),
+ scope: opts.scope,
+ pattern: opts.pattern,
+ replacement: opts.replacement,
+ cfi: opts.cfi,
+ sectionHref: opts.sectionHref,
+ isRegex: opts.isRegex ?? false,
+ enabled: opts.enabled ?? true,
+ caseSensitive: opts.caseSensitive ?? true,
+ order: opts.order ?? 1000,
+ wholeWord: opts.wholeWord ?? true,
+ };
+}
+
+function mergeRules(
+ globalRules: ProofreadRule[] | undefined,
+ bookRules: ProofreadRule[] | undefined,
+): ProofreadRule[] {
+ const map = new Map();
+
+ (globalRules ?? []).forEach((r) => map.set(r.id, r));
+ (bookRules ?? []).forEach((r) => map.set(r.id, r));
+
+ return [...map.values()].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+}
+
+export const useProofreadStore = create(() => ({
+ getBookRules: (bookKey: string) => {
+ const { getViewSettings } = useReaderStore.getState();
+ const viewSettings = getViewSettings(bookKey);
+ return viewSettings?.proofreadRules || [];
+ },
+
+ getGlobalRules: () => {
+ const { settings } = useSettingsStore.getState();
+ return settings.globalViewSettings.proofreadRules || [];
+ },
+
+ getMergedRules: (bookKey: string) => {
+ const { settings } = useSettingsStore.getState();
+ const { getViewSettings } = useReaderStore.getState();
+ const viewSettings = getViewSettings(bookKey);
+
+ return mergeRules(settings.globalViewSettings.proofreadRules, viewSettings?.proofreadRules);
+ },
+
+ addRule: async (envConfig, bookKey, options) => {
+ const rule = createProofreadRule(options);
+
+ if (options.scope === 'library') {
+ await addGlobalRule(envConfig, rule);
+ } else {
+ await addBookRule(envConfig, bookKey, rule, options.scope);
+ }
+
+ return rule;
+ },
+
+ updateRule: async (envConfig, bookKey, ruleId, updates) => {
+ if (updates.scope === 'library') {
+ await updateGlobalRule(envConfig, ruleId, updates);
+ } else {
+ await updateBookRule(envConfig, bookKey, ruleId, updates);
+ }
+ },
+
+ removeRule: async (envConfig, bookKey, ruleId, scope) => {
+ if (scope === 'library') {
+ await removeGlobalRule(envConfig, ruleId);
+ } else {
+ await removeBookRule(envConfig, bookKey, ruleId);
+ }
+ },
+
+ toggleRule: async (envConfig, bookKey, ruleId) => {
+ const { getMergedRules } = useProofreadStore.getState();
+ const mergedRules = getMergedRules(bookKey);
+ const rule = mergedRules.find((r) => r.id === ruleId);
+
+ if (!rule) {
+ throw new Error(`Rule not found: ${ruleId}`);
+ }
+
+ const { updateRule } = useProofreadStore.getState();
+ await updateRule(envConfig, bookKey, ruleId, { enabled: !rule.enabled });
+ },
+}));
+
+async function addBookRule(
+ envConfig: EnvConfigType,
+ bookKey: string,
+ rule: ProofreadRule,
+ scope: ProofreadScope,
+): Promise {
+ const { getViewSettings } = useReaderStore.getState();
+
+ const viewSettings = getViewSettings(bookKey);
+ if (!viewSettings) return;
+
+ const existingRules = viewSettings.proofreadRules || [];
+
+ if (scope === 'selection') {
+ // Always add new single-instance rules (each has unique ID)
+ existingRules.push(rule);
+ } else {
+ // Check for duplicates in book scope
+ const existing = existingRules.find(
+ (r) => r.pattern === rule.pattern && r.isRegex === rule.isRegex && r.scope !== 'selection',
+ );
+
+ if (existing) {
+ Object.assign(existing, {
+ replacement: rule.replacement,
+ enabled: rule.enabled,
+ order: rule.order,
+ });
+ } else {
+ existingRules.push(rule);
+ }
+ }
+
+ await updateBookViewSettings(envConfig, bookKey, existingRules);
+}
+
+async function updateBookRule(
+ envConfig: EnvConfigType,
+ bookKey: string,
+ ruleId: string,
+ updates: Partial>,
+): Promise {
+ const { getViewSettings } = useReaderStore.getState();
+
+ const viewSettings = getViewSettings(bookKey);
+ if (!viewSettings) {
+ throw new Error(`No viewSettings found for book: ${bookKey}`);
+ }
+
+ const existingRules = viewSettings.proofreadRules || [];
+ const updatedRules = existingRules.map((r) => (r.id === ruleId ? { ...r, ...updates } : r));
+
+ await updateBookViewSettings(envConfig, bookKey, updatedRules);
+}
+
+async function removeBookRule(
+ envConfig: EnvConfigType,
+ bookKey: string,
+ ruleId: string,
+): Promise {
+ const { getViewSettings } = useReaderStore.getState();
+
+ const viewSettings = getViewSettings(bookKey);
+ if (!viewSettings) {
+ throw new Error(`No viewSettings found for book: ${bookKey}`);
+ }
+
+ const existingRules = viewSettings.proofreadRules || [];
+ const filteredRules = existingRules.filter((r) => r.id !== ruleId);
+
+ await updateBookViewSettings(envConfig, bookKey, filteredRules);
+}
+
+async function updateBookViewSettings(
+ envConfig: EnvConfigType,
+ bookKey: string,
+ rules: ProofreadRule[],
+): Promise {
+ const { getViewSettings, setViewSettings } = useReaderStore.getState();
+ const { getConfig, saveConfig } = useBookDataStore.getState();
+ const { settings } = useSettingsStore.getState();
+
+ const viewSettings = getViewSettings(bookKey);
+ if (!viewSettings) {
+ throw new Error(`No viewSettings found for book: ${bookKey}`);
+ }
+
+ const updatedViewSettings: ViewSettings = {
+ ...viewSettings,
+ proofreadRules: rules,
+ };
+
+ setViewSettings(bookKey, updatedViewSettings);
+
+ const config = getConfig(bookKey);
+ if (config) {
+ await saveConfig(
+ envConfig,
+ bookKey,
+ { ...config, viewSettings: updatedViewSettings, updatedAt: Date.now() },
+ settings,
+ );
+ }
+}
+
+async function addGlobalRule(envConfig: EnvConfigType, rule: ProofreadRule): Promise {
+ const { settings } = useSettingsStore.getState();
+ if (!settings || !settings.globalViewSettings) return;
+
+ const globalRules = settings.globalViewSettings.proofreadRules || [];
+
+ const existing = globalRules.find(
+ (r) => r.pattern === rule.pattern && r.isRegex === rule.isRegex,
+ );
+
+ if (existing) {
+ Object.assign(existing, {
+ replacement: rule.replacement,
+ enabled: rule.enabled,
+ order: rule.order,
+ });
+ await updateGlobalSettings(envConfig, globalRules);
+ } else {
+ await updateGlobalSettings(envConfig, [...globalRules, rule]);
+ }
+}
+
+async function updateGlobalRule(
+ envConfig: EnvConfigType,
+ ruleId: string,
+ updates: Partial>,
+): Promise {
+ const { settings } = useSettingsStore.getState();
+ const globalRules = settings.globalViewSettings.proofreadRules || [];
+
+ const updatedRules = globalRules.map((r) => (r.id === ruleId ? { ...r, ...updates } : r));
+
+ await updateGlobalSettings(envConfig, updatedRules);
+}
+
+async function removeGlobalRule(envConfig: EnvConfigType, ruleId: string): Promise {
+ const { settings } = useSettingsStore.getState();
+ const globalRules = settings.globalViewSettings.proofreadRules || [];
+
+ const filteredRules = globalRules.filter((r) => r.id !== ruleId);
+ await updateGlobalSettings(envConfig, filteredRules);
+}
+
+async function updateGlobalSettings(
+ envConfig: EnvConfigType,
+ rules: ProofreadRule[],
+): Promise {
+ const { settings, setSettings, saveSettings } = useSettingsStore.getState();
+
+ const updatedSettings: SystemSettings = {
+ ...settings,
+ globalViewSettings: {
+ ...settings.globalViewSettings,
+ proofreadRules: rules,
+ },
+ };
+
+ setSettings(updatedSettings);
+ await saveSettings(envConfig, updatedSettings);
+}
+
+export function validateReplacementRulePattern(
+ pattern: string,
+ isRegex: boolean,
+): { valid: boolean; error?: string } {
+ if (!pattern?.trim()) {
+ return { valid: false, error: 'Pattern cannot be empty' };
+ }
+
+ if (isRegex) {
+ try {
+ new RegExp(pattern);
+ return { valid: true };
+ } catch (error) {
+ return {
+ valid: false,
+ error: error instanceof Error ? error.message : 'Invalid regex pattern',
+ };
+ }
+ }
+
+ return { valid: true };
+}
diff --git a/apps/readest-app/src/types/book.ts b/apps/readest-app/src/types/book.ts
index 7f34250c..77e10246 100644
--- a/apps/readest-app/src/types/book.ts
+++ b/apps/readest-app/src/types/book.ts
@@ -210,24 +210,24 @@ export interface ScreenConfig {
screenOrientation: 'auto' | 'portrait' | 'landscape';
}
+export type ProofreadScope = 'selection' | 'book' | 'library';
-export interface ReplacementRule {
+export interface ProofreadRule {
id: string;
+ scope: ProofreadScope;
pattern: string;
replacement: string;
+ cfi?: string;
+ sectionHref?: string;
enabled: boolean;
isRegex: boolean;
order: number; // Lower numbers apply first
- singleInstance?: boolean; // If true, only replace the specific occurrence
- sectionHref?: string; // Section where the single-instance replacement applies
- occurrenceIndex?: number; // Which occurrence in the section (0-based)
wholeWord?: boolean; // Match whole words only (uses \b word boundaries)
caseSensitive?: boolean; // Case-sensitive matching (default true)
- global?: boolean; // Marks global-scope rules explicitly
}
-export interface ReplacementRulesConfig {
- replacementRules?: ReplacementRule[];
+export interface ProofreadRulesConfig {
+ proofreadRules?: ProofreadRule[];
}
export interface ViewSettings
@@ -239,7 +239,7 @@ export interface ViewSettings
TTSConfig,
TranslatorConfig,
ScreenConfig,
- ReplacementRulesConfig {}
+ ProofreadRulesConfig {}
export interface BookProgress {
location: string;
diff --git a/apps/readest-app/src/utils/sel.ts b/apps/readest-app/src/utils/sel.ts
index f8cc44ba..205d9d8e 100644
--- a/apps/readest-app/src/utils/sel.ts
+++ b/apps/readest-app/src/utils/sel.ts
@@ -27,6 +27,7 @@ export interface TextSelection {
text: string;
range: Range;
index: number;
+ cfi?: string;
href?: string;
annotated?: boolean;
}
diff --git a/apps/readest-app/src/utils/word.ts b/apps/readest-app/src/utils/word.ts
new file mode 100644
index 00000000..6a2bfc2e
--- /dev/null
+++ b/apps/readest-app/src/utils/word.ts
@@ -0,0 +1,86 @@
+// Helper to check if selected text is a whole word (has word boundaries on both sides)
+// Note: Word boundary checks only apply to space-separated languages (English, etc.)
+// CJK languages (Chinese, Japanese, Korean) don't require boundary checks
+export const isWholeWord = (range: Range, selectedText: string): boolean => {
+ try {
+ const trimmed = selectedText.trim();
+ if (!trimmed) return false;
+
+ // Unicode-aware patterns
+ const wordCharPattern = /[\p{L}\p{N}\p{M}_]/u;
+ const cjkPattern = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+
+ // Must contain at least one word character
+ if (!wordCharPattern.test(trimmed)) return false;
+
+ // CJK text doesn't need boundary checks (no spaces between words)
+ if (cjkPattern.test(trimmed)) return true;
+
+ // Phrases (with spaces/punctuation) are always valid
+ if (/[\s\p{P}\p{S}]/u.test(trimmed)) return true;
+
+ // For single words in space-separated languages, check boundaries
+ const { charBefore, charAfter } = getBoundaryChars(range);
+ const isWordChar = (char: string) => wordCharPattern.test(char);
+
+ return (!charBefore || !isWordChar(charBefore)) && (!charAfter || !isWordChar(charAfter));
+ } catch (e) {
+ console.warn('Failed to check whole word:', e);
+ return /[\p{L}\p{N}\p{M}_]/u.test(selectedText);
+ }
+};
+
+// Helper to get characters before and after the selection
+const getBoundaryChars = (range: Range): { charBefore: string; charAfter: string } => {
+ let charBefore = '';
+ let charAfter = '';
+
+ try {
+ // Get character before
+ const startNode = range.startContainer;
+ if (startNode.nodeType === Node.TEXT_NODE) {
+ const textNode = startNode as Text;
+ if (range.startOffset > 0) {
+ charBefore = textNode.textContent?.charAt(range.startOffset - 1) || '';
+ } else {
+ // Check previous sibling
+ let prev = startNode.previousSibling;
+ while (prev && prev.nodeType !== Node.TEXT_NODE) {
+ prev = prev.previousSibling;
+ }
+ if (prev?.nodeType === Node.TEXT_NODE) {
+ const prevText = (prev as Text).textContent || '';
+ charBefore = prevText.charAt(prevText.length - 1);
+ }
+ }
+ }
+
+ // Get character after
+ const endNode = range.endContainer;
+ if (endNode.nodeType === Node.TEXT_NODE) {
+ const textNode = endNode as Text;
+ const textContent = textNode.textContent || '';
+ if (range.endOffset < textContent.length) {
+ charAfter = textContent.charAt(range.endOffset);
+ } else {
+ // Check next sibling
+ let next = textNode.nextSibling;
+ while (next && next.nodeType !== Node.TEXT_NODE) {
+ next = next.nextSibling;
+ }
+ if (next?.nodeType === Node.TEXT_NODE) {
+ charAfter = ((next as Text).textContent || '').charAt(0);
+ }
+ }
+ }
+ } catch (e) {
+ console.warn('[getBoundaryChars] Error:', e);
+ }
+
+ return { charBefore, charAfter };
+};
+
+export const getWordCount = (text: string): number => {
+ if (!text) return 0;
+ return text.trim().split(/\s+/).filter(Boolean).length;
+};
diff --git a/apps/readest-app/src/utils/wordLimit.ts b/apps/readest-app/src/utils/wordLimit.ts
deleted file mode 100644
index ab216e22..00000000
--- a/apps/readest-app/src/utils/wordLimit.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-export const MAX_REPLACEMENT_WORDS = 30;
-
-export const getWordCount = (text: string): number => {
- if (!text) return 0;
- return text.trim().split(/\s+/).filter(Boolean).length;
-};
-
-export const isWordLimitExceeded = (text: string): boolean => {
- return getWordCount(text) > MAX_REPLACEMENT_WORDS;
-};
diff --git a/packages/foliate-js b/packages/foliate-js
index d15091c5..43f30812 160000
--- a/packages/foliate-js
+++ b/packages/foliate-js
@@ -1 +1 @@
-Subproject commit d15091c5239d6a2720a8a80d5036d725f6b9a9d3
+Subproject commit 43f30812d19f49c9539cf9ca4fb558f90422c624