oidc-client/samples/Angular/node_modules/@angular-devkit/core/node/resolve.js

OpenID Connect (OIDC) & OAuth2 client library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
 * @license
 * Copyright Google Inc. All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
const fs = require("fs");
const path = require("path");
const src_1 = require("../src");
const fs_1 = require("./fs");
/**
 * Exception thrown when a module could not be resolved.
 */
class ModuleNotFoundException extends src_1.BaseException {
    constructor(moduleName, basePath) {
        super(`Could not find module ${JSON.stringify(moduleName)} from ${JSON.stringify(basePath)}.`);
        this.moduleName = moduleName;
        this.basePath = basePath;
        this.code = 'MODULE_NOT_FOUND';
    }
}
exports.ModuleNotFoundException = ModuleNotFoundException;
/**
 * Returns a list of all the callers from the resolve() call.
 * @returns {string[]}
 * @private
 */
function _caller() {
    // see https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
    const error = Error;
    const origPrepareStackTrace = error.prepareStackTrace;
    error.prepareStackTrace = (_, stack) => stack;
    const stack = (new Error()).stack;
    error.prepareStackTrace = origPrepareStackTrace;
    return stack ? stack.map(x => x.getFileName()).filter(x => !!x) : [];
}
/**
 * Get the global directory for node_modules. This is based on NPM code itself, and may be subject
 * to change, but is relatively stable.
 * @returns {string} The path to node_modules itself.
 * @private
 */
function _getGlobalNodeModules() {
    let globalPrefix;
    if (process.env.PREFIX) {
        globalPrefix = process.env.PREFIX;
    }
    else if (process.platform === 'win32') {
        // c:\node\node.exe --> prefix=c:\node\
        globalPrefix = path.dirname(process.execPath);
    }
    else {
        // /usr/local/bin/node --> prefix=/usr/local
        globalPrefix = path.dirname(path.dirname(process.execPath));
        // destdir only is respected on Unix
        const destdir = process.env.DESTDIR;
        if (destdir) {
            globalPrefix = path.join(destdir, globalPrefix);
        }
    }
    return (process.platform !== 'win32')
        ? path.resolve(globalPrefix || '', 'lib', 'node_modules')
        : path.resolve(globalPrefix || '', 'node_modules');
}
let _resolveHook = null;
function setResolveHook(hook) {
    _resolveHook = hook;
}
exports.setResolveHook = setResolveHook;
/**
 * Resolve a package using a logic similar to npm require.resolve, but with more options.
 * @param x The package name to resolve.
 * @param options A list of options. See documentation of those options.
 * @returns {string} Path to the index to include, or if `resolvePackageJson` option was
 *                   passed, a path to that file.
 * @throws {ModuleNotFoundException} If no module with that name was found anywhere.
 */
function resolve(x, options) {
    if (_resolveHook) {
        const maybe = _resolveHook(x, options);
        if (maybe) {
            return maybe;
        }
    }
    const readFileSync = fs.readFileSync;
    const extensions = options.extensions || Object.keys(require.extensions);
    const basePath = options.basedir;
    options.paths = options.paths || [];
    if (/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/.test(x)) {
        let res = path.resolve(basePath, x);
        if (x === '..' || x.slice(-1) === '/') {
            res += '/';
        }
        const m = loadAsFileSync(res) || loadAsDirectorySync(res);
        if (m) {
            return m;
        }
    }
    else {
        const n = loadNodeModulesSync(x, basePath);
        if (n) {
            return n;
        }
    }
    // Fallback to checking the local (callee) node modules.
    if (options.checkLocal) {
        const callers = _caller();
        for (const caller of callers) {
            const localDir = path.dirname(caller);
            if (localDir !== options.basedir) {
                try {
                    return resolve(x, Object.assign({}, options, { checkLocal: false, checkGlobal: false, basedir: localDir }));
                }
                catch (e) {
                    // Just swap the basePath with the original call one.
                    if (!(e instanceof ModuleNotFoundException)) {
                        throw e;
                    }
                }
            }
        }
    }
    // Fallback to checking the global node modules.
    if (options.checkGlobal) {
        const globalDir = path.dirname(_getGlobalNodeModules());
        if (globalDir !== options.basedir) {
            try {
                return resolve(x, Object.assign({}, options, { checkLocal: false, checkGlobal: false, basedir: globalDir }));
            }
            catch (e) {
                // Just swap the basePath with the original call one.
                if (!(e instanceof ModuleNotFoundException)) {
                    throw e;
                }
            }
        }
    }
    throw new ModuleNotFoundException(x, basePath);
    function loadAsFileSync(x) {
        if (fs_1.isFile(x)) {
            return x;
        }
        return extensions.map(ex => x + ex).find(f => fs_1.isFile(f)) || null;
    }
    function loadAsDirectorySync(x) {
        const pkgfile = path.join(x, 'package.json');
        if (fs_1.isFile(pkgfile)) {
            if (options.resolvePackageJson) {
                return pkgfile;
            }
            try {
                const body = readFileSync(pkgfile, 'UTF8');
                const pkg = JSON.parse(body);
                if (pkg['main']) {
                    if (pkg['main'] === '.' || pkg['main'] === './') {
                        pkg['main'] = 'index';
                    }
                    const m = loadAsFileSync(path.resolve(x, pkg['main']));
                    if (m) {
                        return m;
                    }
                    const n = loadAsDirectorySync(path.resolve(x, pkg['main']));
                    if (n) {
                        return n;
                    }
                }
            }
            catch (_a) { }
        }
        return loadAsFileSync(path.join(x, '/index'));
    }
    function loadNodeModulesSync(x, start) {
        const dirs = nodeModulesPaths(start, options);
        for (const dir of dirs) {
            const m = loadAsFileSync(path.join(dir, '/', x));
            if (m) {
                return m;
            }
            const n = loadAsDirectorySync(path.join(dir, '/', x));
            if (n) {
                return n;
            }
        }
        return null;
    }
    function nodeModulesPaths(start, opts) {
        const modules = ['node_modules'];
        if (process.env.BAZEL_TARGET) {
            // When running test under Bazel, node_modules have to be resolved
            // differently. node_modules are installed in the `npm` workspace.
            // For more info, see `yarn_install` rule in WORKSPACE file.
            modules.push(path.join('npm', 'node_modules'));
        }
        // ensure that `start` is an absolute path at this point,
        // resolving against the process' current working directory
        let absoluteStart = path.resolve(start);
        if (opts && opts.preserveSymlinks === false) {
            try {
                absoluteStart = fs.realpathSync(absoluteStart);
            }
            catch (err) {
                if (err.code !== 'ENOENT') {
                    throw err;
                }
            }
        }
        let prefix = '/';
        if (/^([A-Za-z]:)/.test(absoluteStart)) {
            prefix = '';
        }
        else if (/^\\\\/.test(absoluteStart)) {
            prefix = '\\\\';
        }
        const paths = [absoluteStart];
        let parsed = path.parse(absoluteStart);
        while (parsed.dir !== paths[paths.length - 1]) {
            paths.push(parsed.dir);
            parsed = path.parse(parsed.dir);
        }
        const dirs = paths.reduce((dirs, aPath) => {
            return dirs.concat(modules.map(function (moduleDir) {
                return path.join(prefix, aPath, moduleDir);
            }));
        }, []);
        return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
    }
}
exports.resolve = resolve;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolve.js","sourceRoot":"./","sources":["packages/angular_devkit/core/node/resolve.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { BaseException } from '../src';\nimport { isFile } from './fs';\n\n/**\n * Exception thrown when a module could not be resolved.\n */\nexport class ModuleNotFoundException extends BaseException {\n  public readonly code: string;\n\n  constructor(public readonly moduleName: string, public readonly basePath: string) {\n    super(`Could not find module ${JSON.stringify(moduleName)} from ${JSON.stringify(basePath)}.`);\n    this.code = 'MODULE_NOT_FOUND';\n  }\n}\n\n/**\n * Returns a list of all the callers from the resolve() call.\n * @returns {string[]}\n * @private\n */\nfunction _caller(): string[] {\n  // see https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi\n  const error = Error as {} as { prepareStackTrace: (x: {}, stack: {}) => {} };\n  const origPrepareStackTrace = error.prepareStackTrace;\n  error.prepareStackTrace = (_, stack) => stack;\n  const stack = (new Error()).stack as {} | undefined as { getFileName(): string }[] | undefined;\n  error.prepareStackTrace = origPrepareStackTrace;\n\n  return stack ? stack.map(x => x.getFileName()).filter(x => !!x) : [];\n}\n\n\n/**\n * Get the global directory for node_modules. This is based on NPM code itself, and may be subject\n * to change, but is relatively stable.\n * @returns {string} The path to node_modules itself.\n * @private\n */\nfunction _getGlobalNodeModules() {\n  let globalPrefix;\n\n  if (process.env.PREFIX) {\n    globalPrefix = process.env.PREFIX;\n  } else if (process.platform === 'win32') {\n    // c:\\node\\node.exe --> prefix=c:\\node\\\n    globalPrefix = path.dirname(process.execPath);\n  } else {\n    // /usr/local/bin/node --> prefix=/usr/local\n    globalPrefix = path.dirname(path.dirname(process.execPath));\n\n    // destdir only is respected on Unix\n    const destdir = process.env.DESTDIR;\n    if (destdir) {\n      globalPrefix = path.join(destdir, globalPrefix);\n    }\n  }\n\n  return (process.platform !== 'win32')\n    ? path.resolve(globalPrefix || '', 'lib', 'node_modules')\n    : path.resolve(globalPrefix || '', 'node_modules');\n}\n\n\nexport interface ResolveOptions {\n  /**\n   * The basedir to use from which to resolve.\n   */\n  basedir: string;\n\n  /**\n   * The list of extensions to resolve. By default uses Object.keys(require.extensions).\n   */\n  extensions?: string[];\n\n  /**\n   * An additional list of paths to look into.\n   */\n  paths?: string[];\n\n  /**\n   * Whether or not to preserve symbolic links. If false, the actual paths pointed by\n   * the symbolic links will be used. This defaults to true.\n   */\n  preserveSymlinks?: boolean;\n\n  /**\n   * Whether to fallback to a global lookup if the basedir one failed.\n   */\n  checkGlobal?: boolean;\n\n  /**\n   * Whether to fallback to using the local caller's directory if the basedir failed.\n   */\n  checkLocal?: boolean;\n\n  /**\n   * Whether to only resolve and return the first package.json file found. By default,\n   * resolves the main field or the index of the package.\n   */\n  resolvePackageJson?: boolean;\n}\n\n\nlet _resolveHook: ((x: string, options: ResolveOptions) => string | null) | null = null;\nexport function setResolveHook(\n  hook: ((x: string, options: ResolveOptions) => string | null) | null,\n) {\n  _resolveHook = hook;\n}\n\n\n/**\n * Resolve a package using a logic similar to npm require.resolve, but with more options.\n * @param x The package name to resolve.\n * @param options A list of options. See documentation of those options.\n * @returns {string} Path to the index to include, or if `resolvePackageJson` option was\n *                   passed, a path to that file.\n * @throws {ModuleNotFoundException} If no module with that name was found anywhere.\n */\nexport function resolve(x: string, options: ResolveOptions): string {\n  if (_resolveHook) {\n    const maybe = _resolveHook(x, options);\n    if (maybe) {\n      return maybe;\n    }\n  }\n\n  const readFileSync = fs.readFileSync;\n\n  const extensions: string[] = options.extensions || Object.keys(require.extensions);\n  const basePath = options.basedir;\n\n  options.paths = options.paths || [];\n\n  if (/^(?:\\.\\.?(?:\\/|$)|\\/|([A-Za-z]:)?[/\\\\])/.test(x)) {\n    let res = path.resolve(basePath, x);\n    if (x === '..' || x.slice(-1) === '/') {\n      res += '/';\n    }\n\n    const m = loadAsFileSync(res) || loadAsDirectorySync(res);\n    if (m) {\n      return m;\n    }\n  } else {\n    const n = loadNodeModulesSync(x, basePath);\n    if (n) {\n      return n;\n    }\n  }\n\n  // Fallback to checking the local (callee) node modules.\n  if (options.checkLocal) {\n    const callers = _caller();\n    for (const caller of callers) {\n      const localDir = path.dirname(caller);\n      if (localDir !== options.basedir) {\n        try {\n          return resolve(x, {\n            ...options,\n            checkLocal: false,\n            checkGlobal: false,\n            basedir: localDir,\n          });\n        } catch (e) {\n          // Just swap the basePath with the original call one.\n          if (!(e instanceof ModuleNotFoundException)) {\n            throw e;\n          }\n        }\n      }\n    }\n  }\n\n  // Fallback to checking the global node modules.\n  if (options.checkGlobal) {\n    const globalDir = path.dirname(_getGlobalNodeModules());\n    if (globalDir !== options.basedir) {\n      try {\n        return resolve(x, {\n          ...options,\n          checkLocal: false,\n          checkGlobal: false,\n          basedir: globalDir,\n        });\n      } catch (e) {\n        // Just swap the basePath with the original call one.\n        if (!(e instanceof ModuleNotFoundException)) {\n          throw e;\n        }\n      }\n    }\n  }\n\n  throw new ModuleNotFoundException(x, basePath);\n\n  function loadAsFileSync(x: string): string | null {\n    if (isFile(x)) {\n      return x;\n    }\n\n    return extensions.map(ex => x + ex).find(f => isFile(f)) || null;\n  }\n\n  function loadAsDirectorySync(x: string): string | null {\n    const pkgfile = path.join(x, 'package.json');\n    if (isFile(pkgfile)) {\n      if (options.resolvePackageJson) {\n        return pkgfile;\n      }\n\n      try {\n        const body = readFileSync(pkgfile, 'UTF8');\n        const pkg = JSON.parse(body);\n\n        if (pkg['main']) {\n          if (pkg['main'] === '.' || pkg['main'] === './') {\n            pkg['main'] = 'index';\n          }\n\n          const m = loadAsFileSync(path.resolve(x, pkg['main']));\n          if (m) {\n            return m;\n          }\n          const n = loadAsDirectorySync(path.resolve(x, pkg['main']));\n          if (n) {\n            return n;\n          }\n        }\n      } catch {}\n    }\n\n    return loadAsFileSync(path.join(x, '/index'));\n  }\n\n  function loadNodeModulesSync(x: string, start: string): string | null {\n    const dirs = nodeModulesPaths(start, options);\n    for (const dir of dirs) {\n      const m = loadAsFileSync(path.join(dir, '/', x));\n      if (m) {\n        return m;\n      }\n      const n = loadAsDirectorySync(path.join(dir, '/', x));\n      if (n) {\n        return n;\n      }\n    }\n\n    return null;\n  }\n\n  function nodeModulesPaths(start: string, opts: ResolveOptions) {\n    const modules = ['node_modules'];\n    if (process.env.BAZEL_TARGET) {\n      // When running test under Bazel, node_modules have to be resolved\n      // differently. node_modules are installed in the `npm` workspace.\n      // For more info, see `yarn_install` rule in WORKSPACE file.\n      modules.push(path.join('npm', 'node_modules'));\n    }\n\n    // ensure that `start` is an absolute path at this point,\n    // resolving against the process' current working directory\n    let absoluteStart = path.resolve(start);\n\n    if (opts && opts.preserveSymlinks === false) {\n      try {\n        absoluteStart = fs.realpathSync(absoluteStart);\n      } catch (err) {\n        if (err.code !== 'ENOENT') {\n          throw err;\n        }\n      }\n    }\n\n    let prefix = '/';\n    if (/^([A-Za-z]:)/.test(absoluteStart)) {\n      prefix = '';\n    } else if (/^\\\\\\\\/.test(absoluteStart)) {\n      prefix = '\\\\\\\\';\n    }\n\n    const paths = [absoluteStart];\n    let parsed = path.parse(absoluteStart);\n    while (parsed.dir !== paths[paths.length - 1]) {\n      paths.push(parsed.dir);\n      parsed = path.parse(parsed.dir);\n    }\n\n    const dirs = paths.reduce((dirs: string[], aPath: string) => {\n      return dirs.concat(modules.map(function (moduleDir) {\n        return path.join(prefix, aPath, moduleDir);\n      }));\n    }, []);\n\n    return opts && opts.paths ? dirs.concat(opts.paths) : dirs;\n  }\n}\n"]}