const delayed = delay({
  source: unit,
  timeout: 100,
})

const delayed = delay({
  source: unit,
  timeout: (payload) => 100,
})

const delayed = delay({
  source: unit,
  timeout: $timeout,
})

const parts = reshape({
  source: $original,
  shape: {
    length: (string) => string.length,
    first: (string) => string.split(' ')[0] || '',
    second: (string) => string.split(' ')[1] || '',
  },
});

function lastTwo<T>(c: { source: Store<T>, target: Unit<{ current: T, prev: T }> }) {
  const store = createStore({ current: c.source.getState(), prev: c.source.getState() })

  store.on(c.source, ({ current: prev }, current) => ({ current, prev }))

  forward({ from: store, to: c.target })
}

const source = createStore(1)
const update = createEvent()

source.on(update, (e) => e + 1)

const target = createEvent<{ current: number, prev: number }>()

target.watch(console.info)

lastTwo({ source, target })

update()
update()
update()

some({
  predicate: true,
  stores: [$first, $second],
})

const debounced = debounce({ source: unit, timeout: 100 })

import { createEffect, attach, Effect } from 'effector'

function borrow<P, D, F>(p: { effect: Effect<P, D, F> }): Effect<P, D, F> {
    return attach({
        effect: p.effect,
        mapParams: (params: P) => params,
    })
}

const parent = createEffect<number, string>()

const local = borrow({ effect: parent })

const received = splitMap({
  source: nameReceived,
  shape: {
    firstName: (string) => string.split(' ')[0], // string | undefined
    lastName: (string) => string.split(' ')[1], // string | undefined
  },
});

const change = createEvent()
const $demo = restore(change, 0)
const $last = lastStates({ source: $demo, count: 3 })

$last.watch(console.info)

change(2)
change(50)
change(200)
change(5)

const change = createEvent()
const $demo = restore(change, 0)
const $last = lastStates({ source: $demo, count: 3, prefill: true })

$last.watch(console.info)

change(2)
change(50)
change(200)
change(5)

const app = createDomain()
const change = app.createEvent()
const $demo = restore(change, 0)

const $states = app.createStore([])
lastStates({ source: $demo, count: 3, target: $states })

$states.watch(console.info)

change(2)
change(50)
change(200)
change(5)

test('from readme', () => {
  const watchFirst = jest.fn();
  const watchLast = jest.fn();

  const nameReceived = createEvent<string>();
  const received = splitMap({
    source: nameReceived,
    cases: {
      firstName: (string) => string.split(' ')[0], // string | undefined
      lastName: (string) => string.split(' ')[1], // string | undefined
    },
  });

  received.firstName.watch(watchFirst);
  received.lastName.watch(watchLast);

  nameReceived('Sergey');
  expect(argumentHistory(watchFirst)).toMatchInlineSnapshot(`
    Array [
      "Sergey",
    ]
  `);
  expect(argumentHistory(watchLast)).toMatchInlineSnapshot(`Array []`);

  watchFirst.mockReset();
  watchFirst.mockReset();
  nameReceived('Sergey Sova');
  expect(argumentHistory(watchFirst)).toMatchInlineSnapshot(`
    Array [
      "Sergey",
    ]
  `);

  // This check fails, now watchLast do not triggered but must
  expect(argumentHistory(watchLast)).toMatchInlineSnapshot(`
    Array [
      "Sova",
    ]
  `);
});

const event = combineEvents({
  events: { event1, event2, event3 }
});

// no second argument anyOf set as default
const $processing = pending({ effects: [loadFirst, loadSecond] });

const $processing = pending({ effects: [loadFirst, loadSecond] }, 'all');

sample({
  source: $store,
  clock: event,
  target: condition({
    if: (value) => value > 1,
    then: firstBranch,
    else: anotherBranch,
  })
})

// Partial destructing argument throw ts error
highLvl: ({ payload }) => payload.lvl >= 50 ? payload.lvl : undefined,

// Full destructing argument works fine
highLvl: ({ settings, payload }) => payload.lvl >= 50 ? payload.lvl : undefined,

const fxStatus = status({ effect: fx })

import { createDomain } from 'effector';
import { pending } from 'patronum/pending';

const app = createDomain()
const loadFirst = app.createEffect().use(() => Promise.resolve(null));
const loadSecond = app.createEffect().use(() => Promise.resolve(2));
const $processing = pending({ domain: app });

$processing.watch((processing) => console.info(`processing: ${processing}`));
// => processing: false

loadFirst();
loadSecond();
// => processing: true

every({
  predicate: true,
  stores: [$first, $second]
})