@push.rocks/smartnpm 2.1.3 → 2.1.4

package/ts/smartnpm.registryurl.ts

@@ -0,0 +1,364 @@
+import * as plugins from './smartnpm.plugins.js';
+import { parseIni } from './smartnpm.ini.js';
+import { homeBeforeNpmrc as rcHome } from './smartnpm.npmrc.js';
+
+/**
+ * resolves the registry url from npm configuration when none is configured,
+ * the way rc('npm') reads it: defaults < config files < npm_* env < process arguments
+ */
+
+const stripJsonComments = (str: string): string => {
+  const strip = (s: string, start?: number, end?: number) => s.slice(start, end).replace(/\S/g, ' ');
+  let insideString = false;
+  let insideComment: false | 'single' | 'multi' = false;
+  let offset = 0;
+  let ret = '';
+  for (let i = 0; i < str.length; i++) {
+    const currentChar = str[i];
+    const nextChar = str[i + 1];
+    if (!insideComment && currentChar === '"') {
+      const escaped = str[i - 1] === '\\' && str[i - 2] !== '\\';
+      if (!escaped) {
+        insideString = !insideString;
+      }
+    }
+    if (insideString) {
+      continue;
+    }
+    if (!insideComment && currentChar + nextChar === '//') {
+      ret += str.slice(offset, i);
+      offset = i;
+      insideComment = 'single';
+      i++;
+    } else if (insideComment === 'single' && currentChar + nextChar === '\r\n') {
+      i++;
+      insideComment = false;
+      ret += strip(str, offset, i);
+      offset = i;
+      continue;
+    } else if (insideComment === 'single' && currentChar === '\n') {
+      insideComment = false;
+      ret += strip(str, offset, i);
+      offset = i;
+    } else if (!insideComment && currentChar + nextChar === '/*') {
+      ret += str.slice(offset, i);
+      offset = i;
+      insideComment = 'multi';
+      i++;
+      continue;
+    } else if (insideComment === 'multi' && currentChar + nextChar === '*/') {
+      i++;
+      insideComment = false;
+      ret += strip(str, offset, i + 1);
+      offset = i + 1;
+      continue;
+    }
+  }
+  return ret + (insideComment ? strip(str.substr(offset)) : str.substr(offset));
+};
+
+const parseConfig = (content: string): any => {
+  if (/^\s*{/.test(content)) {
+    return JSON.parse(stripJsonComments(content));
+  }
+  return parseIni(content);
+};
+
+const readConfigFile = (file: any): string | undefined => {
+  if (file == null || typeof file !== 'string') {
+    return undefined;
+  }
+  try {
+    return plugins.fs.readFileSync(plugins.path.join(file), 'utf-8');
+  } catch {
+    return undefined;
+  }
+};
+
+const findUp = (rel: string): string | undefined => {
+  const find = (start: string): string | undefined => {
+    const file = plugins.path.join(start, rel);
+    try {
+      plugins.fs.statSync(file);
+      return file;
+    } catch {
+      if (plugins.path.dirname(start) !== start) {
+        return find(plugins.path.dirname(start));
+      }
+    }
+  };
+  return find(process.cwd());
+};
+
+const envConfig = (prefix: string): Record<string, any> => {
+  const obj: Record<string, any> = {};
+  for (const k in process.env) {
+    if (k.toLowerCase().indexOf(prefix.toLowerCase()) !== 0) {
+      continue;
+    }
+    const keypath = k.substring(prefix.length).split('__').filter((subkey) => subkey !== '');
+    let cursor: any = obj;
+    keypath.forEach((subkey, i) => {
+      if (!subkey || typeof cursor !== 'object') {
+        return;
+      }
+      if (i === keypath.length - 1) {
+        cursor[subkey] = process.env[k];
+      }
+      if (cursor[subkey] === undefined) {
+        cursor[subkey] = {};
+      }
+      cursor = cursor[subkey];
+    });
+  }
+  return obj;
+};
+
+const isNumber = (x: any): boolean => {
+  if (typeof x === 'number') {
+    return true;
+  }
+  if (/^0x[0-9a-f]+$/i.test(x)) {
+    return true;
+  }
+  return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+};
+
+/**
+ * parses process arguments without options (minimist semantics)
+ */
+const parseArgv = (argsArg: string[]): Record<string, any> => {
+  let args = argsArg;
+  const argv: Record<string, any> = { _: [] };
+  const isConstructorOrProto = (obj: any, key: string) =>
+    (key === 'constructor' && typeof obj[key] === 'function') || key === '__proto__';
+  const setKey = (obj: any, keys: string[], value: any) => {
+    let o = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (isConstructorOrProto(o, key)) {
+        return;
+      }
+      if (o[key] === undefined) {
+        o[key] = {};
+      }
+      if (o[key] === Object.prototype || o[key] === Number.prototype || o[key] === String.prototype) {
+        o[key] = {};
+      }
+      if (o[key] === Array.prototype) {
+        o[key] = [];
+      }
+      o = o[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    if (isConstructorOrProto(o, lastKey)) {
+      return;
+    }
+    if (o === Object.prototype || o === Number.prototype || o === String.prototype) {
+      o = {};
+    }
+    if (o === Array.prototype) {
+      o = [];
+    }
+    if (o[lastKey] === undefined || typeof o[lastKey] === 'boolean') {
+      o[lastKey] = value;
+    } else if (Array.isArray(o[lastKey])) {
+      o[lastKey].push(value);
+    } else {
+      o[lastKey] = [o[lastKey], value];
+    }
+  };
+  const setArg = (key: string, val: any) => {
+    setKey(argv, key.split('.'), isNumber(val) ? Number(val) : val);
+  };
+
+  let notFlags: string[] = [];
+  if (args.indexOf('--') !== -1) {
+    notFlags = args.slice(args.indexOf('--') + 1);
+    args = args.slice(0, args.indexOf('--'));
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    let key: string;
+    let next: string;
+    if (/^--.+=/.test(arg)) {
+      const m = arg.match(/^--([^=]+)=([\s\S]*)$/)!;
+      setArg(m[1], m[2]);
+    } else if (/^--no-.+/.test(arg)) {
+      setArg(arg.match(/^--no-(.+)/)![1], false);
+    } else if (/^--.+/.test(arg)) {
+      key = arg.match(/^--(.+)/)![1];
+      next = args[i + 1];
+      if (next !== undefined && !/^(-|--)[^-]/.test(next)) {
+        setArg(key, next);
+        i += 1;
+      } else if (/^(true|false)$/.test(next)) {
+        setArg(key, next === 'true');
+        i += 1;
+      } else {
+        setArg(key, true);
+      }
+    } else if (/^-[^-]+/.test(arg)) {
+      const letters = arg.slice(1, -1).split('');
+      let broken = false;
+      for (let j = 0; j < letters.length; j++) {
+        next = arg.slice(j + 2);
+        if (next === '-') {
+          setArg(letters[j], next);
+          continue;
+        }
+        if (/[A-Za-z]/.test(letters[j]) && next[0] === '=') {
+          setArg(letters[j], next.slice(1));
+          broken = true;
+          break;
+        }
+        if (/[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+          setArg(letters[j], next);
+          broken = true;
+          break;
+        }
+        if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+          setArg(letters[j], arg.slice(j + 2));
+          broken = true;
+          break;
+        } else {
+          setArg(letters[j], true);
+        }
+      }
+      key = arg.slice(-1)[0];
+      if (!broken && key !== '-') {
+        if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1])) {
+          setArg(key, args[i + 1]);
+          i += 1;
+        } else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
+          setArg(key, args[i + 1] === 'true');
+          i += 1;
+        } else {
+          setArg(key, true);
+        }
+      }
+    } else {
+      argv._.push(!isNumber(arg) ? arg : Number(arg));
+    }
+  }
+  for (const k of notFlags) {
+    argv._.push(k);
+  }
+  return argv;
+};
+
+const isSpecificValue = (val: any) =>
+  val instanceof Buffer || val instanceof Date || val instanceof RegExp;
+
+const cloneSpecificValue = (val: any): any => {
+  if (val instanceof Buffer) {
+    const x = Buffer.alloc(val.length);
+    val.copy(x);
+    return x;
+  } else if (val instanceof Date) {
+    return new Date(val.getTime());
+  } else if (val instanceof RegExp) {
+    return new RegExp(val);
+  }
+  throw new Error('Unexpected situation');
+};
+
+const deepCloneArray = (arr: any[]): any[] => {
+  const clone: any[] = [];
+  arr.forEach((item, index) => {
+    if (typeof item === 'object' && item !== null) {
+      if (Array.isArray(item)) {
+        clone[index] = deepCloneArray(item);
+      } else if (isSpecificValue(item)) {
+        clone[index] = cloneSpecificValue(item);
+      } else {
+        clone[index] = deepExtend({}, item);
+      }
+    } else {
+      clone[index] = item;
+    }
+  });
+  return clone;
+};
+
+const deepExtend = (target: any, ...sources: any[]): any => {
+  const safeGetProperty = (object: any, property: string) =>
+    property === '__proto__' ? undefined : object[property];
+  for (const obj of sources) {
+    if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+      continue;
+    }
+    for (const key of Object.keys(obj)) {
+      const src = safeGetProperty(target, key);
+      const val = safeGetProperty(obj, key);
+      if (val === target) {
+        continue;
+      } else if (typeof val !== 'object' || val === null) {
+        target[key] = val;
+      } else if (Array.isArray(val)) {
+        target[key] = deepCloneArray(val);
+      } else if (isSpecificValue(val)) {
+        target[key] = cloneSpecificValue(val);
+      } else if (typeof src !== 'object' || src === null || Array.isArray(src)) {
+        target[key] = deepExtend({}, val);
+      } else {
+        target[key] = deepExtend(src, val);
+      }
+    }
+  }
+  return target;
+};
+
+const readNpmRc = (): Record<string, any> => {
+  const name = 'npm';
+  const argv = parseArgv(process.argv.slice(2));
+  const env = envConfig(name + '_');
+  const configs: any[] = [{ registry: 'https://registry.npmjs.org/' }];
+  const configFiles: string[] = [];
+  const addConfigFile = (file: any) => {
+    if (configFiles.indexOf(file) >= 0) {
+      return;
+    }
+    const fileConfig = readConfigFile(file);
+    if (fileConfig) {
+      configs.push(parseConfig(fileConfig));
+      configFiles.push(file);
+    }
+  };
+  if (process.platform !== 'win32') {
+    addConfigFile(plugins.path.join('/etc', name, 'config'));
+    addConfigFile(plugins.path.join('/etc', name + 'rc'));
+  }
+  if (rcHome) {
+    addConfigFile(plugins.path.join(rcHome, '.config', name, 'config'));
+    addConfigFile(plugins.path.join(rcHome, '.config', name));
+    addConfigFile(plugins.path.join(rcHome, '.' + name, 'config'));
+    addConfigFile(plugins.path.join(rcHome, '.' + name + 'rc'));
+  }
+  addConfigFile(findUp('.' + name + 'rc'));
+  if (env.config) {
+    addConfigFile(env.config);
+  }
+  if (argv.config) {
+    addConfigFile(argv.config);
+  }
+  return deepExtend(
+    {},
+    ...configs,
+    env,
+    argv,
+    configFiles.length
+      ? { configs: configFiles, config: configFiles[configFiles.length - 1] }
+      : undefined,
+  );
+};
+
+/**
+ * the registry url npm would use for a package scope, always ending in a slash
+ */
+export const getDefaultRegistryUrl = (scope: string): string => {
+  const result = readNpmRc();
+  const url = result[`${scope}:registry`] || result.config_registry || result.registry;
+  return url.slice(-1) === '/' ? url : `${url}/`;
+};