10998746305

Committed 23 Sep 2024 04:47PM UTC coverage: 31.843% (-0.05%) from 31.895%

Build # 10998746305

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9780 from ForumMagnum/text-replacement-cleanup

forgot a cleanup commit

Run Details

5077 of 41397 branches covered (12.26%)

Branch coverage included in aggregate %.

0 of 9 new or added lines in 1 file covered. (0.0%)

2 existing lines in 1 file now uncovered.

29460 of 67062 relevant lines covered (43.93%)

184.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

3.19

/packages/lesswrong/components/hooks/useReplaceTextContent.ts

import { textReplacementsSetting } from "@/lib/publicSettings";
import { useRef } from "react";

type ReplacementTuple = [string, string];

interface WalkNodeTreeOptions {
  inspect: (node: Node) => boolean;
  collect: (node: Node) => boolean;
  callback?: (node: Node) => void;
}

const PROCESSED_FLAG = Symbol('processed');

function markProcessed(node: Node) {
  (node as any)[PROCESSED_FLAG] = true;
}

function isProcessed(node: Node): boolean {
  return !!(node as any)[PROCESSED_FLAG];
}

function walkNodeTree(root: Node, options: WalkNodeTreeOptions) {
  const { inspect, collect, callback } = options;

  const walker = document.createTreeWalker(
    root,
    NodeFilter.SHOW_ALL,
    {
      acceptNode: function(node) {
        if (!inspect(node)) return NodeFilter.FILTER_REJECT;
        if (!collect(node)) return NodeFilter.FILTER_SKIP;
        return NodeFilter.FILTER_ACCEPT;
      }
    }
  );

  const nodes = [];
  let n;
  // eslint-disable-next-line no-cond-assign
  while (n = walker.nextNode()) {
    // callback?.(n);
    nodes.push(n);
  }

  return nodes;
}

function textNodesUnder(el: Node) {
  return walkNodeTree(el, {
    inspect: n => !['STYLE', 'SCRIPT'].includes(n.nodeName),
    collect: n => (n.nodeType === Node.TEXT_NODE),
    //callback: n => console.log(n.nodeName, n),
  });
}

function matchCaseFormat(original: string, replacement: string) {
  if (original === original.toUpperCase()) {
    return replacement.toUpperCase();
  }

  if (original === original.toLowerCase()) {
    return replacement.toLowerCase();
  }

  if (original[0] === original[0].toUpperCase()) {
    return replacement.charAt(0).toUpperCase() + replacement.slice(1).toLowerCase();
  }

  return replacement.toLowerCase();
}

function replaceText(node: Node, replacements: ReplacementTuple[]) {
  if (isProcessed(node)) return;

  let text = node.textContent ?? '';
  let modified = false;

  replacements.forEach(([searchText, replacementText]) => {
    const searchWords = searchText.split(/\s+/);
    const replaceWords = replacementText.split(/\s+/);

    // Create a pattern that matches both spaced and unspaced versions
    const regexPattern = searchWords.map(word => `(${word})`).join('\\s*');
    const regex = new RegExp(`(${regexPattern})(\\s*)`, 'gi');

    text = text.replace(regex, (match, ...args) => {
      modified = true;
      const capturedWords = args.slice(0, -3);  // Exclude the last two items (offset and original string)
      const trailingWhitespace = args[args.length - 3] ?? '';  // Get trailing whitespace

      // Determine if original had spaces between words
      const hadSpaces = match.trim() !== match.replace(/\s+/g, '');

      const replacedPhrase = replaceWords.map((word, index) => 
        matchCaseFormat(capturedWords[index] ?? '', word)
      ).join(hadSpaces ? ' ' : '');

      return replacedPhrase + trailingWhitespace;
    });
  });

  if (modified) {
    node.textContent = text;
  }

  markProcessed(node);
}

export function useReplaceTextContent() {
  const replacements: ReplacementTuple[] = Object.entries(textReplacementsSetting.get());
  const observerRef = useRef<MutationObserver | null>();

  return () => {
    for (let node of textNodesUnder(document.body)) {
      replaceText(node, replacements);
    }

    if (!observerRef.current) {
      const observer = new MutationObserver((mutations) => {
        mutations.forEach((mutation) => {
          if (mutation.type === 'childList') {
            mutation.addedNodes.forEach((node) => {
              if (node.nodeType === Node.ELEMENT_NODE) {
                for (let textNode of textNodesUnder(node)) {
                  replaceText(textNode, replacements);
                }
              } else if (node.nodeType === Node.TEXT_NODE) {
                replaceText(node, replacements);
              }
            });
          } else if (mutation.type === 'characterData') {
            replaceText(mutation.target, replacements);
          }
        });
      });  

      observerRef.current = observer;
    }

    observerRef.current.observe(document.body, {
      childList: true,
      subtree: true,
      characterData: true, 
      characterDataOldValue: true,
    });    
  };
}

1	import { textReplacementsSetting } from "@/lib/publicSettings";	3✔
2	import { useRef } from "react";	1✔
3
4	type ReplacementTuple = [string, string];
5
6	interface WalkNodeTreeOptions {
7	inspect: (node: Node) => boolean;
8	collect: (node: Node) => boolean;
9	callback?: (node: Node) => void;
10	}
11
12	const PROCESSED_FLAG = Symbol('processed');	1✔
13
14	function markProcessed(node: Node) {
15	(node as any)[PROCESSED_FLAG] = true;	×
16	}
17
18	function isProcessed(node: Node): boolean {
19	return !!(node as any)[PROCESSED_FLAG];	×
20	}
21
22	function walkNodeTree(root: Node, options: WalkNodeTreeOptions) {
23	const { inspect, collect, callback } = options;	×
24
25	const walker = document.createTreeWalker(	×
26	root,
27	NodeFilter.SHOW_ALL,
28	{
29	acceptNode: function(node) {
NEW 30	if (!inspect(node)) return NodeFilter.FILTER_REJECT;	×
NEW 31	if (!collect(node)) return NodeFilter.FILTER_SKIP;	×
UNCOV 32	return NodeFilter.FILTER_ACCEPT;	×
33	}
34	}
35	);
36
NEW 37	const nodes = [];	×
38	let n;
39	// eslint-disable-next-line no-cond-assign
40	while (n = walker.nextNode()) {	×
41	// callback?.(n);
42	nodes.push(n);	×
43	}
44
45	return nodes;	×
46	}
47
48	function textNodesUnder(el: Node) {
49	return walkNodeTree(el, {	×
50	inspect: n => !['STYLE', 'SCRIPT'].includes(n.nodeName),	×
51	collect: n => (n.nodeType === Node.TEXT_NODE),	×
52	//callback: n => console.log(n.nodeName, n),
53	});
54	}
55
56	function matchCaseFormat(original: string, replacement: string) {
NEW 57	if (original === original.toUpperCase()) {	×
NEW 58	return replacement.toUpperCase();	×
59	}
60
NEW 61	if (original === original.toLowerCase()) {	×
NEW 62	return replacement.toLowerCase();	×
63	}
64
65	if (original[0] === original[0].toUpperCase()) {	×
66	return replacement.charAt(0).toUpperCase() + replacement.slice(1).toLowerCase();	×
67	}
68
UNCOV 69	return replacement.toLowerCase();	×
70	}
71
72	function replaceText(node: Node, replacements: ReplacementTuple[]) {
73	if (isProcessed(node)) return;	×
74
75	let text = node.textContent ?? '';	×
76	let modified = false;	×
77
78	replacements.forEach(([searchText, replacementText]) => {	×
79	const searchWords = searchText.split(/\s+/);	×
80	const replaceWords = replacementText.split(/\s+/);	×
81
82	// Create a pattern that matches both spaced and unspaced versions
83	const regexPattern = searchWords.map(word => `(${word})`).join('\\s*');	×
84	const regex = new RegExp(`(${regexPattern})(\\s*)`, 'gi');	×
85
86	text = text.replace(regex, (match, ...args) => {	×
87	modified = true;	×
88	const capturedWords = args.slice(0, -3); // Exclude the last two items (offset and original string)	×
NEW 89	const trailingWhitespace = args[args.length - 3] ?? ''; // Get trailing whitespace	×
90
91	// Determine if original had spaces between words
92	const hadSpaces = match.trim() !== match.replace(/\s+/g, '');	×
93
94	const replacedPhrase = replaceWords.map((word, index) =>	×
NEW 95	matchCaseFormat(capturedWords[index] ?? '', word)	×
96	).join(hadSpaces ? ' ' : '');	×
97
98	return replacedPhrase + trailingWhitespace;	×
99	});
100	});
101
102	if (modified) {	×
103	node.textContent = text;	×
104	}
105
106	markProcessed(node);	×
107	}
108
109	export function useReplaceTextContent() {
110	const replacements: ReplacementTuple[] = Object.entries(textReplacementsSetting.get());	×
111	const observerRef = useRef<MutationObserver \| null>();	×
112
113	return () => {	×
114	for (let node of textNodesUnder(document.body)) {	×
115	replaceText(node, replacements);	×
116	}
117
118	if (!observerRef.current) {	×
119	const observer = new MutationObserver((mutations) => {	×
120	mutations.forEach((mutation) => {	×
121	if (mutation.type === 'childList') {	×
122	mutation.addedNodes.forEach((node) => {	×
123	if (node.nodeType === Node.ELEMENT_NODE) {	×
124	for (let textNode of textNodesUnder(node)) {	×
125	replaceText(textNode, replacements);	×
126	}
127	} else if (node.nodeType === Node.TEXT_NODE) {	×
128	replaceText(node, replacements);	×
129	}
130	});
131	} else if (mutation.type === 'characterData') {	×
132	replaceText(mutation.target, replacements);	×
133	}
134	});
135	});
136
137	observerRef.current = observer;	×
138	}
139
140	observerRef.current.observe(document.body, {	×
141	childList: true,
142	subtree: true,
143	characterData: true,
144	characterDataOldValue: true,
145	});
146	};
147	}

ForumMagnum / ForumMagnum / 10998746305

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous