import { forkJoin } from 'rxjs';

// Array of Observables
function forkJoin<A extends readonly unknown[]>(
  sources: readonly [...ObservableInputTuple<A>]
): Observable<A>;

// Dictionary of Observables
function forkJoin<T extends Record<string, ObservableInput<any>>>(
  sourcesObject: T
): Observable<{ [K in keyof T]: ObservedValueOf<T[K]> }>;

// With result selector
function forkJoin<A extends readonly unknown[], R>(
  sources: readonly [...ObservableInputTuple<A>],
  resultSelector: (...values: A) => R
): Observable<R>;

import { forkJoin } from 'rxjs';
import { ajax } from 'rxjs/ajax';

const requests$ = forkJoin({
  user: ajax.getJSON('/api/user'),
  posts: ajax.getJSON('/api/posts'),
  comments: ajax.getJSON('/api/comments')
});

requests$.subscribe({
  next: ({ user, posts, comments }) => {
    console.log('User:', user);
    console.log('Posts:', posts.length);
    console.log('Comments:', comments.length);
  },
  error: err => console.error('Request failed:', err),
  complete: () => console.log('All requests completed!')
});

import { forkJoin } from 'rxjs';
import { ajax } from 'rxjs/ajax';

const requests$ = forkJoin([
  ajax.getJSON('/api/user'),
  ajax.getJSON('/api/posts'),
  ajax.getJSON('/api/comments')
]);

requests$.subscribe(([user, posts, comments]) => {
  console.log('Got all data:', { user, posts, comments });
});

import { forkJoin, of, timer } from 'rxjs';

const observable = forkJoin({
  foo: of(1, 2, 3, 4),          // Emits 1,2,3,4 then completes
  bar: Promise.resolve(8),       // Resolves to 8
  baz: timer(4000)               // Emits 0 after 4 seconds
});

observable.subscribe({
  next: value => console.log(value),
  complete: () => console.log('Done!')
});

// After 4 seconds:
// { foo: 4, bar: 8, baz: 0 }
// Done!

import { forkJoin } from 'rxjs';
import { ajax } from 'rxjs/ajax';
import { map } from 'rxjs/operators';

function loadUserProfile(userId: string) {
  return forkJoin({
    user: ajax.getJSON(`/api/users/${userId}`),
    posts: ajax.getJSON(`/api/users/${userId}/posts`),
    followers: ajax.getJSON(`/api/users/${userId}/followers`),
    following: ajax.getJSON(`/api/users/${userId}/following`)
  }).pipe(
    map(({ user, posts, followers, following }) => ({
      ...user,
      stats: {
        postsCount: posts.length,
        followersCount: followers.length,
        followingCount: following.length
      }
    }))
  );
}

loadUserProfile('123').subscribe(profile => {
  console.log('Profile loaded:', profile);
});

import { forkJoin, of } from 'rxjs';
import { map, delay } from 'rxjs/operators';

function validateUsername(username: string) {
  return ajax.getJSON(`/api/check-username?name=${username}`).pipe(
    map(response => response.available)
  );
}

function validateEmail(email: string) {
  return ajax.getJSON(`/api/check-email?email=${email}`).pipe(
    map(response => response.valid)
  );
}

function validateForm(username: string, email: string) {
  return forkJoin({
    usernameValid: validateUsername(username),
    emailValid: validateEmail(email)
  }).pipe(
    map(({ usernameValid, emailValid }) => ({
      valid: usernameValid && emailValid,
      errors: {
        username: !usernameValid ? 'Username already taken' : null,
        email: !emailValid ? 'Invalid email' : null
      }
    }))
  );
}

validateForm('john', 'john@example.com').subscribe(result => {
  if (result.valid) {
    console.log('Form is valid!');
  } else {
    console.log('Validation errors:', result.errors);
  }
});

import { forkJoin, from } from 'rxjs';
import { mergeMap } from 'rxjs/operators';

function uploadFile(file: File): Observable<string> {
  const formData = new FormData();
  formData.append('file', file);
  
  return ajax.post('/api/upload', formData).pipe(
    map(response => response.response.url)
  );
}

function uploadFiles(files: File[]) {
  const uploads$ = files.map(file => uploadFile(file));
  return forkJoin(uploads$);
}

const files = [file1, file2, file3];

uploadFiles(files).subscribe({
  next: urls => console.log('All files uploaded:', urls),
  error: err => console.error('Upload failed:', err)
});

import { forkJoin, defer } from 'rxjs';

function runMigration(name: string, fn: () => Promise<void>) {
  return defer(() => {
    console.log(`Running migration: ${name}`);
    return from(fn()).pipe(
      tap(() => console.log(`Completed migration: ${name}`))
    );
  });
}

const migrations$ = forkJoin([
  runMigration('001_create_users', () => db.exec('CREATE TABLE users...')),
  runMigration('002_create_posts', () => db.exec('CREATE TABLE posts...')),
  runMigration('003_add_indexes', () => db.exec('CREATE INDEX...'))
]);

migrations$.subscribe({
  next: () => console.log('All migrations completed'),
  error: err => console.error('Migration failed:', err)
});

import { forkJoin, of } from 'rxjs';

forkJoin([
  of(1, 2, 3, 4),  // Last value: 4
  of('a', 'b', 'c') // Last value: 'c'
]).subscribe(([num, letter]) => {
  console.log(num, letter); // 4, 'c'
});

import { forkJoin, of, EMPTY } from 'rxjs';

// This completes WITHOUT emitting
forkJoin([
  of(1, 2, 3),
  EMPTY  // Completes without emitting
]).subscribe({
  next: x => console.log('Next:', x),  // Never called
  complete: () => console.log('Complete!')  // Called immediately
});

import { forkJoin, of, throwError } from 'rxjs';
import { catchError } from 'rxjs/operators';

// Without error handling - entire forkJoin errors
forkJoin([
  of(1),
  throwError(() => new Error('Fail')),
  of(3)
]).subscribe({
  next: x => console.log(x),  // Never called
  error: err => console.error('Error:', err)  // Called with error
});

// With error handling - provides fallback
forkJoin([
  of(1),
  throwError(() => new Error('Fail')).pipe(
    catchError(() => of('recovered'))
  ),
  of(3)
]).subscribe({
  next: x => console.log(x)  // [1, 'recovered', 3]
});