linting

shakyShane · shakyShane · commit 261d905a36f8 · 2025-03-03T20:19:26.000Z
diff --git a/injected/entry-points/chrome.js b/injected/entry-points/chrome.js
@@ -3,7 +3,7 @@
  */
 import { isTrackerOrigin } from '../src/trackers';
 import { computeLimitedSiteObject } from '../src/utils';
-import contentScopeFeatures from 'ddg:contentScopeFeatures'
+import contentScopeFeatures from 'ddg:contentScopeFeatures';
 
 /**
  * Inject all the overwrites into the page.
@@ -49,7 +49,9 @@ function init() {
     const reusableMethodName = '_rm' + randomString();
     const reusableSecret = '_r' + randomString();
     const siteObject = computeLimitedSiteObject();
-    const initialScript = contentScopeFeatures + `
+    const initialScript =
+        contentScopeFeatures +
+        `
       /* global contentScopeFeatures */
       contentScopeFeatures.load({
           platform: {
diff --git a/injected/scripts/entry-points.js b/injected/scripts/entry-points.js
@@ -1,4 +1,4 @@
-import { bundle } from './utils/build.js'
+import { bundle } from './utils/build.js';
 import { parseArgs, write } from '../../scripts/script-utils.js';
 
 /**
@@ -59,31 +59,31 @@ const builds = {
     },
 };
 
-async function init () {
+async function init() {
     // verify the input
-    const requiredFields = []
-    const args = parseArgs(process.argv.slice(2), requiredFields)
+    const requiredFields = [];
+    const args = parseArgs(process.argv.slice(2), requiredFields);
 
     // if a platform was given as an argument, just build that platform
     if (args.platform) {
-        const build = builds[args.platform]
+        const build = builds[args.platform];
         if (!build) {
-            throw new Error('unsupported platform: ' + args.platform)
+            throw new Error('unsupported platform: ' + args.platform);
         }
-        const output = await bundle({ scriptPath: build.input, platform: args.platform })
+        const output = await bundle({ scriptPath: build.input, platform: args.platform });
 
         // bundle and write the output
-        write([build.output], output)
+        write([build.output], output);
 
-        return
+        return;
     }
 
     // otherwise, just build them all
     for (const [injectName, build] of Object.entries(builds)) {
-        const output = await bundle({ scriptPath: build.input, platform: injectName })
-        write(build.output, output)
+        const output = await bundle({ scriptPath: build.input, platform: injectName });
+        write(build.output, output);
         console.log('✅', injectName, build.output[0]);
     }
 }
 
-init()
+init();
diff --git a/injected/scripts/utils/build.js b/injected/scripts/utils/build.js
@@ -1,15 +1,15 @@
-import { platformSupport } from '../../src/features.js'
-import { readFileSync } from 'fs'
-import { cwd } from '../../../scripts/script-utils.js'
-import { join } from 'path'
-import * as esbuild from 'esbuild'
-const ROOT = join(cwd(import.meta.url), '..', '..')
-const DEBUG = false
+import { platformSupport } from '../../src/features.js';
+import { readFileSync } from 'fs';
+import { cwd } from '../../../scripts/script-utils.js';
+import { join } from 'path';
+import * as esbuild from 'esbuild';
+const ROOT = join(cwd(import.meta.url), '..', '..');
+const DEBUG = false;
 
 const contentScopePath = 'src/content-scope-features.js';
 const contentScopeName = 'contentScopeFeatures';
 
-const prefixMessage = '/*! © DuckDuckGo ContentScopeScripts protections https://github.com/duckduckgo/content-scope-scripts/ */'
+const prefixMessage = '/*! © DuckDuckGo ContentScopeScripts protections https://github.com/duckduckgo/content-scope-scripts/ */';
 
 /**
  * @param {object} params
@@ -19,23 +19,18 @@ const prefixMessage = '/*! © DuckDuckGo ContentScopeScripts protections https:/
  * @param {string} [params.name]
  * @return {Promise<string>}
  */
-export async function bundle (params) {
-    const {
-        scriptPath,
-        platform,
-        name,
-        featureNames,
-    } = params
-
-    const extensions = ['firefox', 'chrome', 'chrome-mv3']
-    const isExtension = extensions.includes(platform)
-    let trackerLookup = '$TRACKER_LOOKUP$'
+export async function bundle(params) {
+    const { scriptPath, platform, name, featureNames } = params;
+
+    const extensions = ['firefox', 'chrome', 'chrome-mv3'];
+    const isExtension = extensions.includes(platform);
+    let trackerLookup = '$TRACKER_LOOKUP$';
     if (!isExtension) {
-        const trackerLookupData = readFileSync('../build/tracker-lookup.json', 'utf8')
-        trackerLookup = trackerLookupData
+        const trackerLookupData = readFileSync('../build/tracker-lookup.json', 'utf8');
+        trackerLookup = trackerLookupData;
     }
-    const suffixMessage = platform === 'firefox' ? `/*# sourceURL=duckduckgo-privacy-protection.js?scope=${name} */` : ''
-    const loadFeaturesPlugin = loadFeatures(platform, featureNames)
+    const suffixMessage = platform === 'firefox' ? `/*# sourceURL=duckduckgo-privacy-protection.js?scope=${name} */` : '';
+    const loadFeaturesPlugin = loadFeatures(platform, featureNames);
     // The code is using a global, that we define here which means once tree shaken we get a browser specific output.
 
     /** @type {import("esbuild").BuildOptions} */
@@ -50,34 +45,34 @@ export async function bundle (params) {
         globalName: name,
         loader: {
             '.css': 'text',
-            '.svg': 'text'
+            '.svg': 'text',
         },
         define: {
             'import.meta.env': 'development',
             'import.meta.injectName': JSON.stringify(platform),
-            'import.meta.trackerLookup': trackerLookup
+            'import.meta.trackerLookup': trackerLookup,
         },
         plugins: [loadFeaturesPlugin, contentFeaturesAsString(platform)],
         footer: {
-            js: suffixMessage
+            js: suffixMessage,
         },
         banner: {
-            js: prefixMessage
-        }
-    }
+            js: prefixMessage,
+        },
+    };
 
-    const result = await esbuild.build(buildOptions)
+    const result = await esbuild.build(buildOptions);
 
     if (result.metafile && DEBUG) {
-        console.log(await esbuild.analyzeMetafile(result.metafile))
+        console.log(await esbuild.analyzeMetafile(result.metafile));
     }
 
     if (result.errors.length === 0 && result.outputFiles) {
-        return result.outputFiles[0].text || ''
+        return result.outputFiles[0].text || '';
     } else {
-        console.log(result.errors)
-        console.log(result.warnings)
-        throw new Error('could not continue')
+        console.log(result.errors);
+        console.log(result.warnings);
+        throw new Error('could not continue');
     }
 }
 
@@ -88,78 +83,76 @@ export async function bundle (params) {
  * @param {string[]} featureNames
  * @returns {import("esbuild").Plugin}
  */
-function loadFeatures (platform, featureNames = platformSupport[platform]) {
-    const pluginId = 'ddg:platformFeatures'
+function loadFeatures(platform, featureNames = platformSupport[platform]) {
+    const pluginId = 'ddg:platformFeatures';
     return {
         name: 'ddg:platformFeatures',
-        setup (build) {
+        setup(build) {
             build.onResolve({ filter: new RegExp(pluginId) }, (args) => {
                 return {
                     path: args.path,
-                    namespace: pluginId
-                }
-            })
+                    namespace: pluginId,
+                };
+            });
             build.onLoad({ filter: /.*/, namespace: pluginId }, () => {
                 // convert a list of feature names to
                 const imports = featureNames.map((featureName) => {
-                    const fileName = getFileName(featureName)
-                    const path = `./src/features/${fileName}.js`
-                    const ident = `ddg_feature_${featureName}`
+                    const fileName = getFileName(featureName);
+                    const path = `./src/features/${fileName}.js`;
+                    const ident = `ddg_feature_${featureName}`;
                     return {
                         ident,
-                        importPath: path
-                    }
-                })
+                        importPath: path,
+                    };
+                });
 
-                const importString = imports.map(imp => `import ${imp.ident} from ${JSON.stringify(imp.importPath)}`)
-                    .join(';\n')
+                const importString = imports.map((imp) => `import ${imp.ident} from ${JSON.stringify(imp.importPath)}`).join(';\n');
 
-                const exportsString = imports.map(imp => `${imp.ident}`)
-                    .join(',\n    ')
+                const exportsString = imports.map((imp) => `${imp.ident}`).join(',\n    ');
 
-                const exportString = `export default {\n    ${exportsString}\n}`
+                const exportString = `export default {\n    ${exportsString}\n}`;
 
                 return {
                     loader: 'js',
                     resolveDir: ROOT,
-                    contents: [importString, exportString].join('\n')
-                }
-            })
-        }
-    }
+                    contents: [importString, exportString].join('\n'),
+                };
+            });
+        },
+    };
 }
 
-function contentFeaturesAsString (platform) {
-    const pluginId = 'ddg:contentScopeFeatures'
+function contentFeaturesAsString(platform) {
+    const pluginId = 'ddg:contentScopeFeatures';
     return {
         /**
          * Load all platform features based on current
          */
         name: pluginId,
-        setup (build) {
+        setup(build) {
             build.onResolve({ filter: new RegExp(pluginId) }, (args) => {
                 return {
                     path: args.path,
-                    namespace: pluginId
-                }
-            })
+                    namespace: pluginId,
+                };
+            });
             build.onLoad({ filter: /.*/, namespace: pluginId }, async () => {
                 const result = await bundle({
                     scriptPath: contentScopePath,
                     name: contentScopeName,
-                    platform
-                })
+                    platform,
+                });
 
-                const encodedString = result.replace(/\r\n/g, '\n')
+                const encodedString = result.replace(/\r\n/g, '\n');
 
                 return {
                     loader: 'text',
                     resolveDir: ROOT,
-                    contents: encodedString
-                }
-            })
-        }
-    }
+                    contents: encodedString,
+                };
+            });
+        },
+    };
 }
 
 /**
@@ -170,4 +163,4 @@ function contentFeaturesAsString (platform) {
  */
 function getFileName(featureName) {
     return featureName.replace(/([a-zA-Z])(?=[A-Z0-9])/g, '$1-').toLowerCase();
-}
+}
diff --git a/injected/src/globals.d.ts b/injected/src/globals.d.ts
@@ -48,6 +48,6 @@ declare module 'ddg:platformFeatures' {
     export default output;
 }
 declare module 'ddg:contentScopeFeatures' {
-    const output: string
+    const output: string;
     export default output;
 }

Original file line number	Diff line number	Diff line change
`@@ -48,6 +48,6 @@ declare module 'ddg:platformFeatures' {`
`48`	`48`	`export default output;`
`49`	`49`	`}`
`50`	`50`	`declare module 'ddg:contentScopeFeatures' {`
`51`		`- const output: string`
	`51`	`+ const output: string;`
`52`	`52`	`export default output;`
`53`	`53`	`}`