WbICHA

type Alph = 'Q' | 'W' | 'E' | 'R' | 'T' | 'Y' | 'U' | 'I' | 'O' | 'P' | 'A' | 'S' | 'D' | 'F' | 'G' | 'H' | 'J' | 'K' | 'L' | 'X' | 'Z' | 'C' | 'V' | 'B' | 'N' | 'M'

type CamelToSnake<T extends string> = T extends `${infer S1}${Alph}${string}` ? T extends `${S1}${infer S2}` ? `${Lowercase<S1>}_${CamelToSnake<Uncapitalize<S2>>}` : T : T;
type AsdSnake = CamelToSnake<'asdAsdAsd'> // asd_asd_asd

type SnakeToCamel<T extends string> = T extends `${infer S1}_${infer S2}` ? `${Lowercase<S1>}${Capitalize<SnakeToCamel<S2>>}` : T;
type AsdCamel = SnakeToCamel<'asd_asd_asd'> // asdAsdAsd

type SnakePropToCamel<T extends PropertyKey> = T extends string ? SnakeToCamel<T> : T;
type CamelPropToSnake<T extends PropertyKey> = T extends string ? CamelToSnake<T> : T;

let camelToSnakeCase: <T extends PropertyKey>(str: T) => CamelPropToSnake<T>;

type CamelObjectToSnake<T extends {[key: string]: any}> = {
  [K in keyof T as CamelPropToSnake<K>]: T[K]
}

function camelCaseObject<T extends {[key: string]: any}>(obj: T) {
  return Object.entries(obj)
    .reduce((acc, [key, value]) =>
        (acc[camelToSnakeCase(key as keyof T)] = value, acc),
      {} as CamelObjectToSnake<T>
    )
}

function camelToSnakeKeysOfArrayObject<T extends Array<{[key: string]: any}>>(arr: T) {
  return arr.map(camelCaseObject) as {
    [K in keyof T]: CamelObjectToSnake<T[K]>
  };
}

camelToSnakeKeysOfArrayObject([{
  aaAa: 1,
  bbBb: true
}, {
  aaAa: 'ggg'
}]);

declare class ViewHack {
  getPosOnScale(currentPos: number): number;
}
describe('some method', () => {
  test('should return smth', () => {
    const view = new View('range-slider', settings);
    jest.spyOn(view as unknown as ViewHack, 'getPosOnScale').mockReturnValue(100);
  });
});

На верхнем уровне скриптов и функций let, в отличии от var, не создаёт свойства на глобальном объекте.

1. Лучше иметь вышку, чем не иметь.
   
2. В 99.99% случаев вышка не нужна для работы.
   
3. Вышка облегчает поиск первой работы.
   
4. Вышка не нужна для эмиграции.
   

1. Если уверены, что длины всех массивов будут равны:
   
   

   const zip = (...arrs) =>
     arrs[0]?.map((n, i) => arrs.map(m => m[i])) ?? [];
   
   
   const result = zip(arr1, arr2);

   
   
   
2. Вместо отсутствующих значений подставляем какое-то дефолтное:
   
   

   const zip = (arrs, defaultValue = null) =>
     Array.from(
       { length: Math.max(...arrs.map(n => n.length)) },
       (n, i) => arrs.map(m => i < m.length ? m[i] : defaultValue)
     );
   
   // или
   
   const zip = (arrs, defaultValue = null) =>
     arrs.reduce((acc, n, i) => (
       n.forEach((m, j) => (acc[j] ??= Array(arrs.length).fill(defaultValue))[i] = m),
       acc
     ), []);

   
   В вашем случае применять, понятное дело, так: const result = zip([ arr1, arr2 ]);.
   
   Пример с разными длинами массивов - zip([ [ 1, 2, 3 ], [], [ 99 ] ], Infinity) - в результате получим
   
   

   [
     [ 1, Infinity,       99 ],
     [ 2, Infinity, Infinity ],
     [ 3, Infinity, Infinity ]
   ]

   
   
   
3. В качестве источников данных могут выступать не обязательно массивы:
   
   

   function* zip(data, defaultValue = null) {
     const iterators = Array.from(data, n => n[Symbol.iterator]());
   
     for (let doneAll = false; (doneAll = !doneAll);) {
       const values = [];
   
       for (const n of iterators) {
         const { value, done } = n.next();
         values.push(done ? defaultValue : value);
         doneAll &&= done;
       }
   
       if (!doneAll) {
         yield values;
       }
     }
   }

   
   В вашем случае применять так: const result = [...zip([ arr1, arr2 ])];.
   
   Пример посложнее, результатом выражения
   
   

   Array.from(zip((function*() {
     yield [ , true, false, NaN ];
     yield 'abcde';
     yield Array(3).keys();
   })()))

   
   будет следующий массив:
   
   

   [
     [ undefined, 'a',    0 ],
     [      true, 'b',    1 ],
     [     false, 'c',    2 ],
     [       NaN, 'd', null ],
     [      null, 'e', null ]
   ]

   
   
   

const val = arr.find(n => n.hasOwnProperty(key))?.[key];

const vals = arr.reduce((acc, n) => (n.hasOwnProperty(key) && acc.push(n[key]), acc), []);

function sumNumbers(maxNumber) {
    const buf = new Int8Array(maxNumber);
    let answer = maxNumber > 2 ? 2 : 0;
    for(let i = 3; i < maxNumber; i += 2) {
        if (buf[i] === 1) {
            continue;
        }
        answer += i;
        const i2 = i * 2;
        for(let j = i * i; j < maxNumber; j += i2) {
            buf[j] = 1;
        }
    }
    
    return answer;
}

class Result<T>{
  public readonly result;
  constructor(result: T){
    this.result = result;
  }  
}

class NumberResult extends Result<number>{
  constructor(result: number){
    super(result);
  }

  public ResultPlusOne(){
    return this.result + 1;
  }
}

class Result{
  public readonly result;
  constructor(result: number){
    this.result = result;
  }  
}

fs.writeFile(file, data[, options], callback)#
History:

• file <string> | <Buffer> | <URL> | <integer> filename or file descriptor
  
• data

  <string> | <Buffer> | <TypedArray> | <DataView> | <Object>

  
  
• options <Object> | <string>
  • encoding <string> | <null> Default: 'utf8'
    
  • mode <integer> Default: 0o666
    
  • flag <string> See support of file system flags. Default: 'w'.
    
  • signal <AbortSignal> allows aborting an in-progress writeFile
    
  
  
• callback <Function>
  • err <Error> | <AggregateError>
    
  
  
  

When file is a filename, asynchronously writes data to the file, replacing the file if it already exists. data can be a string or a buffer.

When file is a file descriptor, the behavior is similar to calling fs.write() directly (which is recommended). See the notes below on using a file descriptor.

The encoding option is ignored if data is a buffer.

If data is a plain object, it must have an own (not inherited) toString function property.
...