Here is a version that works with both readonly and mutable tuples types and a separator.

type Join<
  TElements,
  TSeparator extends string,
> = TElements extends Readonly<[infer First, ...infer Rest]>
  ? Rest extends ReadonlyArray<string>
    ? First extends string
      ? `${First}${Rest extends [] ? '' : TSeparator}${Join<Rest, TSeparator>}`
      : never
    : never
  : '';

type MutableTuple = ["a", "b", "c"];
type MutableTupleJoined = Join<MutableTuple, " | ">;
//   ^? "a | b | c"

type ReadonlyTuple = readonly ["a", "b", "c"];
type ReadonlyTupleJoined = Join<ReadonlyTuple, " | ">;
//   ^? "a | b | c"

A readonly type often comes from const assertions e.g.

const tuple = ["a", "b", "c"] as const;
type Joined = Join<typeof tuple, " | ">;

When inlining the tuple type, it is usually mutable e.g.

type Joined = Join<["a", "b", "c"], " | ">;

You can use destructuring to concatenate everything into a temporary array, and then use filter to remove any empty elements before calling join on the lot.

let var1 = "var1";
let arr1 = ["one", "", "two"];
let var2 = ""

const myString = "result:" + [var1, ...arr1, var2].filter(s => s).join(' ');

console.log(myString);

I think a more ergonomic (if not idiomatic) approach would be using template literals, for example:

Code in TypeScript Playground

const example = {
  IdNumber: 524242,
  notes: 'testing\n\ntesting 2\n\ntesting 3',
  update () {
    this.notes = `IdNumber: ${this.IdNumber}\n\n${this.notes}`;
  },
};

console.log(example.notes); // "testing\n\ntesting 2\n\ntesting 3"
example.update();
console.log(example.notes); // "IdNumber: 524242\n\ntesting\n\ntesting 2\n\ntesting 3"