10 examples of 'unable to resolve path to module' in JavaScript

22
resolveModule(path: string) {
23
    const value = this.zMap[path];
24
    if (!value) {
25
        throw new Error("can't resolve " + path);
26
    }
27
    return value;
28
}

25
resolveModule(name)
26
{
27
    let module = require('./' + name);
28
    return module;
29
}

4
export function resolveFrom(sys: StencilSystem, fromDir: string, moduleId: string, silent: boolean = false): string {
5
  if (typeof fromDir !== 'string') {
6
    throw new TypeError(`Expected \`fromDir\` to be of type \`string\`, got \`${typeof fromDir}\``);
7
  }
8
9
  if (typeof moduleId !== 'string') {
10
    throw new TypeError(`Expected \`moduleId\` to be of type \`string\`, got \`${typeof moduleId}\``);
11
  }
12
13
  fromDir = sys.path.resolve(fromDir);
14
  const fromFile = sys.path.join(fromDir, 'noop.js');
15
16
  const resolveFileName = () => sys.module._resolveFilename(moduleId, {
17
    id: fromFile,
18
    filename: fromFile,
19
    paths: sys.module._nodeModulePaths(fromDir)
20
  });
21
22
  if (silent) {
23
    try {
24
      return resolveFileName();
25
    } catch (err) {
26
      return null;
27
    }
28
  }
29
30
  return resolveFileName();
31
}

112
function resolveImportedModule(url) {
113
  const importTree = url.split(path.sep)
114
  const moduleName = importTree.shift()
115
116
  const modulePath = require.resolve(moduleName, {
117
    paths: [path.join(path.dirname(state.theme.entry))],
118
  })
119
120
  // No path was provided, return the imported node module
121
  if (!importTree.length) {
122
    return modulePath
123
  }
124
125
  // User is importing a specific file, find it and return its location
126
  const moduleIndex = modulePath.indexOf(moduleName) + moduleName.length
127
  const packagePath = modulePath.slice(0, moduleIndex)
128
  const importedModule = path.join(packagePath, ...importTree)
129
130
  return importedModule
131
}

73
function resolve_as_module(cwd, id, cache) {
74
	return node_modules_dirs(cwd).reduce(
75
		// for each dir in module dirs using cwd:
76
		(promise, dir) => promise.catch(
77
			// resolve as a file using dir/id as file
78
			() => resolveAsFile(path.join(dir, id), cache)
79
				// otherwise, resolve as a directory using dir/id as dir
80
				.catch(() => resolve_as_directory(path.join(dir, id), cache))
81
		),
82
		Promise.reject()
83
	);
84
}

25
public async resolveModule(mod: string): Promise {
26
  let nodeFolder = await this.nodeFolder
27
  let yarnFolder = await this.yarnFolder
28
  if (yarnFolder) {
29
    let s = await statAsync(path.join(yarnFolder, mod, 'package.json'))
30
    if (s && s.isFile()) return path.join(yarnFolder, mod)
31
  }
32
  if (nodeFolder) {
33
    let s = await statAsync(path.join(nodeFolder, mod, 'package.json'))
34
    if (s && s.isFile()) return path.join(nodeFolder, mod)
35
  }
36
  return null
37
}

39
export function tryRequire(module, paths = []) {
40
  try {
41
    let moduleName = module;
42
    if (paths.length > 0) moduleName = require.resolve(moduleName, { paths });
43
    return require(moduleName); // eslint-disable-line global-require
44
  } catch (e) {
45
    return null;
46
  }
47
}

287
static async findRoot(path) {
288
  return findRoot(path);
289
}

91
function findModule(name) {
92
  var result = '';
93
  try {
94
    result = nodeResolve.sync(name, { basedir: process.cwd() });
95
  } catch(e) {
96
    try {
97
      result = nodeResolve.sync(name, { basedir: __dirname });
98
    } catch(e) {
99
      console.error('Cannot find module ' + name + ' from ' + process.cwd()  + ' or ' + __dirname);
100
      throw e;
101
    }
102
  }
103
  return result;
104
}

30
protected resolve(moduleName: string, path: string): string {
31
    return this.pck.resolveModulePath(moduleName, path).split(paths.sep).join('/');
32
}