How to use @ionic/utils-array - 10 common examples

req.redirects(25);

  if (proxy) {
    const superagentProxy = await import('superagent-proxy');
    superagentProxy(superagent);

    if ((req as any).proxy) { // TODO: create/use `@types/superagent-proxy`
      (req as any).proxy(proxy);
    } else {
      debug(`Cannot install proxy--req.proxy not defined`);
    }
  }

  if (ssl) {
    const cafiles = conform(ssl.cafile);
    const certfiles = conform(ssl.certfile);
    const keyfiles = conform(ssl.keyfile);

    if (cafiles.length > 0) {
      req.ca(await Promise.all(cafiles.map(p => readFile(p, { encoding: 'utf8' }))));
    }

    if (certfiles.length > 0) {
      req.cert(await Promise.all(certfiles.map(p => readFile(p, { encoding: 'utf8' }))));
    }

    if (keyfiles.length > 0) {
      req.key(await Promise.all(keyfiles.map(p => readFile(p, { encoding: 'utf8' }))));
    }
  }

  return { req };

req.redirects(25);

  if (proxy) {
    const superagentProxy = await import('superagent-proxy');
    superagentProxy(superagent);

    if ((req as any).proxy) { // TODO: create/use `@types/superagent-proxy`
      (req as any).proxy(proxy);
    } else {
      debug(`Cannot install proxy--req.proxy not defined`);
    }
  }

  if (ssl) {
    const cafiles = conform(ssl.cafile);
    const certfiles = conform(ssl.certfile);
    const keyfiles = conform(ssl.keyfile);

    if (cafiles.length > 0) {
      req.ca(await Promise.all(cafiles.map(p => readFile(p, { encoding: 'utf8' }))));
    }

    if (certfiles.length > 0) {
      req.cert(await Promise.all(certfiles.map(p => readFile(p, { encoding: 'utf8' }))));
    }

    if (keyfiles.length > 0) {
      req.key(await Promise.all(keyfiles.map(p => readFile(p, { encoding: 'utf8' }))));
    }
  }

if (proxy) {
    const superagentProxy = await import('superagent-proxy');
    superagentProxy(superagent);

    if ((req as any).proxy) { // TODO: create/use `@types/superagent-proxy`
      (req as any).proxy(proxy);
    } else {
      debug(`Cannot install proxy--req.proxy not defined`);
    }
  }

  if (ssl) {
    const cafiles = conform(ssl.cafile);
    const certfiles = conform(ssl.certfile);
    const keyfiles = conform(ssl.keyfile);

    if (cafiles.length > 0) {
      req.ca(await Promise.all(cafiles.map(p => readFile(p, { encoding: 'utf8' }))));
    }

    if (certfiles.length > 0) {
      req.cert(await Promise.all(certfiles.map(p => readFile(p, { encoding: 'utf8' }))));
    }

    if (keyfiles.length > 0) {
      req.key(await Promise.all(keyfiles.map(p => readFile(p, { encoding: 'utf8' }))));
    }
  }

  return { req };
}

if (!type || !this.e.project.directory) {
      return; // TODO: will we need hooks outside a project?
    }

    const pkg = await this.e.project.requirePackageJson();

    debug(`Looking for ${ancillary(this.script)} npm script.`);

    if (pkg.scripts && pkg.scripts[this.script]) {
      debug(`Invoking ${ancillary(this.script)} npm script.`);
      const [ pkgManager, ...pkgArgs ] = await pkgManagerArgs(this.e.config.get('npmClient'), { command: 'run', script: this.script });
      await this.e.shell.run(pkgManager, pkgArgs, {});
    }

    const projectHooks = this.e.project.config.get('hooks');
    const hooks = projectHooks ? conform(projectHooks[this.name]) : [];

    for (const h of hooks) {
      const p = path.resolve(this.e.project.directory, h);

      try {
        if (path.extname(p) !== '.js') {
          throw new Error(`Hooks must be .js files with a function for its default export.`);
        }

        const hook = await this.loadHookFn(p);

        if (!hook) {
          throw new Error(`Module must have a function for its default export.`);
        }

        await hook(lodash.assign({}, input, {

async function _findExecutables(program: string, { PATH = process.env.PATH, PATHEXT = process.env.PATHEXT || DEFAULT_PATHEXT }: WhichOptions = {}): Promise {
  const pathParts = getPathParts(PATH);
  let programNames: string[];

  // if windows, cycle through all possible executable extensions
  // ex: node.exe, npm.cmd, etc.
  if (TERMINAL_INFO.windows) {
    const exts = getPathParts(PATHEXT).map(ext => ext.toLowerCase());
    // don't append extensions if one has already been provided
    programNames = exts.includes(pathlib.extname(program).toLowerCase()) ? [program] : exts.map(ext => program + ext);
  } else {
    programNames = [program];
  }

  return ([] as string[]).concat(...await map(programNames, async (programName): Promise =>
    concurrentFilter(pathParts.map(p => pathlib.join(p, programName)), async p => isExecutableFile(p))));
}

private async getFilesAndSizesAndHashesForGlobPattern(buildDir: string): Promise {
    const contents = await readdirp(buildDir, { filter: item => !/(css|js)\.map$/.test(item.path) });
    const stats = await map(contents, async (f): Promise<[string, fs.Stats]> => [f, await stat(f)]);
    const files = stats.filter(([ , s ]) => !s.isDirectory());

    const items = await Promise.all(files.map(([f, s]) => this.getFileAndSizeAndHashForFile(buildDir, f, s)));

    return items.filter(item => item.href !== 'pro-manifest.json');
  }

export function addHook(baseDir: string, hooks: string | string[] | undefined, hook: string): string[] {
  const hookPaths = conform(hooks);
  const resolvedHookPaths = hookPaths.map(p => path.resolve(baseDir, p));

  if (!resolvedHookPaths.includes(path.resolve(baseDir, hook))) {
    hookPaths.push(hook);
  }

  return hookPaths;
}

export function locateHook(baseDir: string, hooks: string[], hook: string): number {
  return conform(hooks).map(p => path.resolve(baseDir, p)).indexOf(path.resolve(baseDir, hook));
}

export function removeHook(baseDir: string, hooks: string | string[] | undefined, hook: string): string[] {
  const hookPaths = conform(hooks);
  const i = locateHook(baseDir, hookPaths, hook);

  if (i >= 0) {
    hookPaths.splice(i, 1);
  }

  return hookPaths;
}

return ([] as string[]).concat(...await map(programNames, async (programName): Promise =>
    concurrentFilter(pathParts.map(p => pathlib.join(p, programName)), async p => isExecutableFile(p))));
}