Merge pull request #320 from nschonni/cspell-setup

chore: add cSpell for spell checking

Author: sokra

.cspell.json

@@ -0,0 +1,37 @@
+{
+  "version": "0.2",
+  "words": [
+    "abcxyz",
+    "addrs",
+    "anotherhashishere",
+    "arcanis",
+    "Builtins",
+    "complexm",
+    "endregion",
+    "entrypoints",
+    "filesystems",
+    "hashishere",
+    "jsons",
+    "Kopeykin",
+    "Koppers",
+    "Maël",
+    "memfs",
+    "mergeable",
+    "Nison",
+    "opensource",
+    "pjson",
+    "pnpapi",
+    "sokra",
+    "subpaths",
+    "tapable",
+    "undescribed",
+    "unreviewed",
+    "vankop",
+    "wpck",
+    "zapp",
+    "zipp",
+    "zippi",
+    "zizizi"
+  ],
+  "ignorePaths": ["package.json", "yarn.lock", "coverage", "*.log"]
+}

lib/ModulesInHierachicDirectoriesPlugin.js

@@ -5,76 +5,5 @@
 
 "use strict";
 
-const forEachBail = require("./forEachBail");
-const getPaths = require("./getPaths");
-
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-
-module.exports = class ModulesInHierachicDirectoriesPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | Array<string>} directories directories
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, directories, target) {
-		this.source = source;
-		this.directories = /** @type {Array<string>} */ ([]).concat(directories);
-		this.target = target;
-	}
-
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync(
-				"ModulesInHierachicDirectoriesPlugin",
-				(request, resolveContext, callback) => {
-					const fs = resolver.fileSystem;
-					const addrs = getPaths(request.path)
-						.paths.map(p => {
-							return this.directories.map(d => resolver.join(p, d));
-						})
-						.reduce((array, p) => {
-							array.push.apply(array, p);
-							return array;
-						}, []);
-					forEachBail(
-						addrs,
-						(addr, callback) => {
-							fs.stat(addr, (err, stat) => {
-								if (!err && stat && stat.isDirectory()) {
-									const obj = {
-										...request,
-										path: addr,
-										request: "./" + request.request,
-										module: false
-									};
-									const message = "looking for modules in " + addr;
-									return resolver.doResolve(
-										target,
-										obj,
-										message,
-										resolveContext,
-										callback
-									);
-								}
-								if (resolveContext.log)
-									resolveContext.log(
-										addr + " doesn't exist or is not a directory"
-									);
-								if (resolveContext.missingDependencies)
-									resolveContext.missingDependencies.add(addr);
-								return callback();
-							});
-						},
-						callback
-					);
-				}
-			);
-	}
-};
+// TODO remove in next major
+module.exports = require("./ModulesInHierarchicalDirectoriesPlugin");

lib/ModulesInHierarchicalDirectoriesPlugin.js

@@ -0,0 +1,80 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const forEachBail = require("./forEachBail");
+const getPaths = require("./getPaths");
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+module.exports = class ModulesInHierarchicalDirectoriesPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | Array<string>} directories directories
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, directories, target) {
+		this.source = source;
+		this.directories = /** @type {Array<string>} */ ([]).concat(directories);
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync(
+				"ModulesInHierarchicalDirectoriesPlugin",
+				(request, resolveContext, callback) => {
+					const fs = resolver.fileSystem;
+					const addrs = getPaths(request.path)
+						.paths.map(p => {
+							return this.directories.map(d => resolver.join(p, d));
+						})
+						.reduce((array, p) => {
+							array.push.apply(array, p);
+							return array;
+						}, []);
+					forEachBail(
+						addrs,
+						(addr, callback) => {
+							fs.stat(addr, (err, stat) => {
+								if (!err && stat && stat.isDirectory()) {
+									const obj = {
+										...request,
+										path: addr,
+										request: "./" + request.request,
+										module: false
+									};
+									const message = "looking for modules in " + addr;
+									return resolver.doResolve(
+										target,
+										obj,
+										message,
+										resolveContext,
+										callback
+									);
+								}
+								if (resolveContext.log)
+									resolveContext.log(
+										addr + " doesn't exist or is not a directory"
+									);
+								if (resolveContext.missingDependencies)
+									resolveContext.missingDependencies.add(addr);
+								return callback();
+							});
+						},
+						callback
+					);
+				}
+			);
+	}
+};

lib/ResolverFactory.js

@@ -23,7 +23,7 @@ const ImportsFieldPlugin = require("./ImportsFieldPlugin");
 const JoinRequestPartPlugin = require("./JoinRequestPartPlugin");
 const JoinRequestPlugin = require("./JoinRequestPlugin");
 const MainFieldPlugin = require("./MainFieldPlugin");
-const ModulesInHierachicDirectoriesPlugin = require("./ModulesInHierachicDirectoriesPlugin");
+const ModulesInHierarchicalDirectoriesPlugin = require("./ModulesInHierarchicalDirectoriesPlugin");
 const ModulesInRootPlugin = require("./ModulesInRootPlugin");
 const NextPlugin = require("./NextPlugin");
 const ParsePlugin = require("./ParsePlugin");
@@ -73,7 +73,7 @@ const UseFilePlugin = require("./UseFilePlugin");
  * @property {boolean=} fullySpecified The request is already fully specified and no extensions or directories are resolved for it
  * @property {boolean=} resolveToContext Resolve to a context instead of a file
  * @property {(string|RegExp)[]=} restrictions A list of resolve restrictions
- * @property {boolean=} useSyncFileSystemCalls Use only the sync constiants of the file system calls
+ * @property {boolean=} useSyncFileSystemCalls Use only the sync constraints of the file system calls
  * @property {boolean=} preferRelative Prefer to resolve module requests as relative requests before falling back to modules
  * @property {boolean=} preferAbsolute Prefer to resolve server-relative urls as absolute paths before falling back to resolve in roots
  */
@@ -280,7 +280,7 @@ exports.createResolver = function (options) {
 
 	resolver.ensureHook("resolve");
 	resolver.ensureHook("internalResolve");
-	resolver.ensureHook("newInteralResolve");
+	resolver.ensureHook("newInternalResolve");
 	resolver.ensureHook("parsedResolve");
 	resolver.ensureHook("describedResolve");
 	resolver.ensureHook("internal");
@@ -302,6 +302,11 @@ exports.createResolver = function (options) {
 	resolver.ensureHook("existingFile");
 	resolver.ensureHook("resolved");
 
+	// TODO remove in next major
+	// cspell:word Interal
+	// Backward-compat
+	resolver.hooks.newInteralResolve = resolver.hooks.newInternalResolve;
+
 	// resolve
 	for (const { source, resolveOptions } of [
 		{ source: "resolve", resolveOptions: { fullySpecified } },
@@ -406,7 +411,7 @@ exports.createResolver = function (options) {
 		if (Array.isArray(item)) {
 			if (item.includes("node_modules") && pnpApi) {
 				plugins.push(
-					new ModulesInHierachicDirectoriesPlugin(
+					new ModulesInHierarchicalDirectoriesPlugin(
 						"raw-module",
 						item.filter(i => i !== "node_modules"),
 						"module"
@@ -417,7 +422,11 @@ exports.createResolver = function (options) {
 				);
 			} else {
 				plugins.push(
-					new ModulesInHierachicDirectoriesPlugin("raw-module", item, "module")
+					new ModulesInHierarchicalDirectoriesPlugin(
+						"raw-module",
+						item,
+						"module"
+					)
 				);
 			}
 		} else {

lib/SymlinkPlugin.js

@@ -34,7 +34,7 @@ module.exports = class SymlinkPlugin {
 			.tapAsync("SymlinkPlugin", (request, resolveContext, callback) => {
 				if (request.ignoreSymlinks) return callback();
 				const pathsResult = getPaths(request.path);
-				const pathSeqments = pathsResult.seqments;
+				const pathSegments = pathsResult.segments;
 				const paths = pathsResult.paths;
 
 				let containsSymlink = false;
@@ -47,7 +47,7 @@ module.exports = class SymlinkPlugin {
 							resolveContext.fileDependencies.add(path);
 						fs.readlink(path, (err, result) => {
 							if (!err && result) {
-								pathSeqments[idx] = result;
+								pathSegments[idx] = result;
 								containsSymlink = true;
 								// Shortcut when absolute symlink found
 								const resultType = getType(result.toString());
@@ -63,11 +63,11 @@ module.exports = class SymlinkPlugin {
 					},
 					(err, idx) => {
 						if (!containsSymlink) return callback();
-						const resultSeqments =
+						const resultSegments =
 							typeof idx === "number"
-								? pathSeqments.slice(0, idx + 1)
-								: pathSeqments.slice();
-						const result = resultSeqments.reduceRight((a, b) => {
+								? pathSegments.slice(0, idx + 1)
+								: pathSegments.slice();
+						const result = resultSegments.reduceRight((a, b) => {
 							return resolver.join(a, b);
 						});
 						const obj = {

lib/getPaths.js

@@ -6,24 +6,24 @@
 "use strict";
 
 module.exports = function getPaths(path) {
-	if (path === "/") return { paths: ["/"], seqments: [""] };
+	if (path === "/") return { paths: ["/"], segments: [""] };
 	const parts = path.split(/(.*?[\\/]+)/);
 	const paths = [path];
-	const seqments = [parts[parts.length - 1]];
+	const segments = [parts[parts.length - 1]];
 	let part = parts[parts.length - 1];
 	path = path.substr(0, path.length - part.length - 1);
 	for (let i = parts.length - 2; i > 2; i -= 2) {
 		paths.push(path);
 		part = parts[i];
 		path = path.substr(0, path.length - part.length) || "/";
-		seqments.push(part.substr(0, part.length - 1));
+		segments.push(part.substr(0, part.length - 1));
 	}
 	part = parts[1];
-	seqments.push(part);
+	segments.push(part);
 	paths.push(part);
 	return {
 		paths: paths,
-		seqments: seqments
+		segments: segments
 	};
 };
 

package.json

@@ -20,6 +20,7 @@
   "devDependencies": {
     "@types/mocha": "^8.0.3",
     "@types/node": "^14.11.1",
+    "cspell": "4.2.8",
     "eslint": "^7.9.0",
     "eslint-config-prettier": "^6.11.0",
     "eslint-plugin-jsdoc": "^30.5.1",
@@ -42,7 +43,7 @@
   "types": "types.d.ts",
   "homepage": "http://github.com/webpack/enhanced-resolve",
   "scripts": {
-    "lint": "yarn run code-lint && yarn run type-lint && yarn run special-lint",
+    "lint": "yarn run code-lint && yarn run type-lint && yarn run special-lint && yarn run spelling",
     "fix": "yarn run code-lint-fix && yarn run special-lint-fix",
     "code-lint": "eslint --cache lib test",
     "code-lint-fix": "eslint --cache lib test --fix",
@@ -51,6 +52,7 @@
     "special-lint-fix": "node node_modules/tooling/inherit-types --write && node node_modules/tooling/format-file-header --write && node node_modules/tooling/generate-types --write",
     "pretty": "prettier --loglevel warn --write \"lib/**/*.{js,json}\" \"test/*.js\"",
     "pretest": "yarn lint",
+    "spelling": "cspell \"**/*.*\"",
     "test": "mocha --full-trace --check-leaks",
     "test:only": "mocha --full-trace --check-leaks",
     "precover": "yarn lint",

test/getPaths.js

@@ -3,23 +3,23 @@ require("should");
 const getPaths = require("../lib/getPaths");
 
 /**
- * @type {[string,{paths: string[], seqments: string[]}][]}
+ * @type {[string,{paths: string[], segments: string[]}][]}
  */
 const cases = [
-	["/a", { paths: ["/a", "/"], seqments: ["a", "/"] }],
-	["/a/", { paths: ["/a/", "/a", "/"], seqments: ["", "a", "/"] }],
-	["/a/b", { paths: ["/a/b", "/a", "/"], seqments: ["b", "a", "/"] }],
+	["/a", { paths: ["/a", "/"], segments: ["a", "/"] }],
+	["/a/", { paths: ["/a/", "/a", "/"], segments: ["", "a", "/"] }],
+	["/a/b", { paths: ["/a/b", "/a", "/"], segments: ["b", "a", "/"] }],
 	[
 		"/a/b/",
-		{ paths: ["/a/b/", "/a/b", "/a", "/"], seqments: ["", "b", "a", "/"] }
+		{ paths: ["/a/b/", "/a/b", "/a", "/"], segments: ["", "b", "a", "/"] }
 	],
-	["/", { paths: ["/"], seqments: [""] }]
+	["/", { paths: ["/"], segments: [""] }]
 ];
 
 cases.forEach(case_ => {
 	it(case_[0], () => {
-		const { paths, seqments } = getPaths(case_[0]);
+		const { paths, segments } = getPaths(case_[0]);
 		paths.should.be.eql(case_[1].paths);
-		seqments.should.be.eql(case_[1].seqments);
+		segments.should.be.eql(case_[1].segments);
 	});
 });

test/resolve.js

@@ -309,7 +309,7 @@ describe("resolve", function () {
 		});
 	});
 
-	it("should not crash when passing undefined everywere", done => {
+	it("should not crash when passing undefined everywhere", done => {
 		resolve(undefined, undefined, undefined, undefined, err => {
 			err.should.be.instanceof(Error);
 			done();

tooling/format-file-header.js

@@ -2,7 +2,7 @@ const path = require("path");
 const fs = require("fs");
 
 // When --write is set, files will be written in place
-// Elsewise it only prints outdated files
+// Otherwise it only prints outdated files
 const doWrite = process.argv.includes("--write");
 
 const allFiles = new Set();