yuriyyakym / awai Goto Github PK

It should not be possible to set family-state node if state with such id exists already.

The leak is caused by Promise.race.
See related issue nodejs/node#17469.

• Configure GitHub action
• Show coverage in readme

Add/check tests and reach 100% coverage

This is related to every Awai node

Add/check tests and reach 100% coverage

Get rid of repeatUntil config option and add another scenario override instead:

scenario(trigger, repeatUntil, callback, config);

So that instead of

scenario(
  draw.events.invoked,
  ({ arguments: [endPoint] }) => {
    currentLayerState.set((layer) => ({ ...layer, endPoint }));
  },
  { repeatUntil: stopDrawing.events.invoked },
);

Developer can write

scenario(
  draw.events.invoked,
  stopDrawing.events.invoked,
  ({ arguments: [endPoint] }) => {
    currentLayerState.set((layer) => ({ ...layer, endPoint }));
  },
);

repeat config option should remain as is.

Check/add tests and reach 100% coverage

It is not minimalistic anymore.

Once node is in registry, we need to know some details about it, like id, tags etc.

Add/check tests and reach 100% coverage

In order to improve code readability in quite common cases, it was decided to make scenario thennable, so that instead of assigning scenario to a variable and then awaiting a final event, like this:

  const drawingScenario = scenario(
    draw.events.invoked,
    stopDrawing.events.invoked,
    ({ arguments: [endPoint] }) => {
      currentLineLayerState.set((layer) => ({ ...layer, endPoint }));
    },
  );

  await drawingScenario.events.expired;

it should be possible to do it like this:

  await scenario(
    draw.events.invoked,
    stopDrawing.events.invoked,
    ({ arguments: [endPoint] }) => {
      currentLineLayerState.set((layer) => ({ ...layer, endPoint }));
    },
  );

It should also warn a user if he is trying to await and infinite scenario.

• Docs
• Diagram

Introduce fulfilled event, which is only emitted on success.
changed event should be emitted always, right after fullfilled and rejected events.

Add/check tests and reach 100% coverage

Add more tests and reach 100% coverage

Add utils tests and reach 100% coverage

It may handle action and readable states.

Current approach:

const items = state();
const createItem = action();

scenario(items.events.changed, () => { /* ... */ });
scenario(createItem.events.invoked, () => { /* ... */ });

Suggested syntax sugar, which would by default take changed event from states, and invoked event from action.

scenario(items, () => { /* ... */ });
scenario(createItem, () => { /* ... */ });

• state.events.changed
• state.onChanged

and

• state.get()
• state.getValue()

Right now the only way to trigger a scenario with multiple AwaiEvents's/promises is to have a trigger callback and use Promise.race, like so:

scenario(
  () => Promise.race([
    action1.events.invoked,
    delay(1000),
  ]),
  () => { /* ... */ }
);

It should also be possible to pass an array or AwaiEvents:

scenario(
  [action1.events.invoked, state1.events.changed],
  () => { /* ... */ }
);

Registry should store references to all nodes.
Registry should have events.registered event.

It will allow to nicely compose scenarios, like in this example for rect drawing scenario:

scenario(startDraw.events.invoked, async ({ arguments: [event]}) => {
  const tool = toolState.get();

  if (tool !== 'rectangle') {
    return;
  }

  currentLayerState.set({
    type: 'rectangle',
    start: getEventPoint(event),
    end: getEventPoint(event)
  });

  const drawScenario = scenario(draw.events.invoked, ({ arguments: [event]}) => {
    currentLayerState.set(layer => ({
      ...layer!,
      end: getEventPoint(event)
    }));
  });

  await endDraw.events.invoked;

  // drawScenario.stop();
});

Notice that after inner scenario is disposed, we can safely handle next drawings.

AsyncState should emit ignored event when outdated promise is resolved. Event should include ignored version number and resolved value.

At the moment scenario is just a syntax sugar for an infinite loop. Also there are variations: scenarioOnce and scenarioOnEvery.

There should be only one scenario with configuration support.

When no callback is passed to then method, it should behave like native Promise - unmodified value.

eg. state.events.changed.then() should return the same promise as state.events.changed.

This is needed for #28.

In current implementation scenario stops when trigger promise is rejected.
This situation may occur when using callback trigger, like this:

scenario(
  () => Promise.race([promise1, promiseThatMayReject]),
  () => /* .... */
);

Related places: action, state and familyState.

Currently cyclic strategy is used, which cases an infinite loop.

Add/check tests and reach 100% coverage

This should be handled in selector and asyncState.
state aleady uses Object.is comparison and behaves as expected.

Add/check tests and reach 100% coverage

• Rename getAbortablePromise to abortable.
• Pass AbortController instead of AbortSignal.

It should follow Promise convention: pending, fulfilled, rejected

• DevHunt
• HN
• LinkedIn blog post
• StackOverflow article
• Dev.to post
• GitHub Discussions

• Receive domain
• Redirect https://www.awai.store & https://awai.store to https://awai.js.org/ with 301 Moved permanently status code.
• Update url in GitHub repository
• Update url in examples

Extend scenario config with the following attributes:

{
  repeat?: number;
  repeatUntil?: PromiseLike | AwaiEvent | PredicateCallback;
}

• repeat - number of times scenario should run before expired event is emited.
• repeatUntil
  • If PromiseLike - repeat unitl resolved
  • If AwaiEvent - repeat until emited
  • If predicate - repeat until returns truthy

When both repeat and repeatUntil are specified, scenario should be expired as soon as any of them are supposed to expire the scenario.

expired event should only be emitted when last scenario callback is finished evaluating.

Get rid of current stop functionality.