@fgaudo/effect-tea - v0.7.2
    Preparing search index...

    Function parent

    • The way to make a parent: its types fixed once, by name (parent<{ state: State; event: Event }>()), then its children declared with child (one) or each (by id), and the parent made with compose. Its messages are its own and { _tag: <child>, message } for each child (with id for children by id); its commands likewise. Fixing the types first is what lets get, set and the rest be typed without annotations, and the parent's own commands, events, external messages and flags, which nothing it returns can reveal, be known.

      Type Parameters

      • T extends Readonly<
            {
                command?: unknown;
                event?: unknown;
                external?: unknown;
                flags?: unknown;
                state: object;
            },
        >

      Returns {
          child: <
              P extends
                  Readonly<
                      {
                          init: | Readonly<
                              {
                                  commands?: readonly any[];
                                  events?: readonly never[];
                                  state: any;
                              },
                          >
                          | ((flags: any) => Step<any, any>);
                          makeModel: any;
                          update: any;
                      },
                  >,
          >(
              program: P,
              place: Placement<Field<T, "state">, StateOf<P>> & Readonly<
                  { subscribed?: (state: Field) => Option<StateOf<P>> },
              > & ObjectState<StateOf<P>>,
          ) => Child<State, P>;
          compose: <
              C extends
                  Readonly<
                      Record<
                          string,
                          | Readonly<
                              {
                                  get: (state: Field) => Option<unknown>;
                                  kind: "one";
                                  program: AnyProgram;
                                  set: (state: Field, child: never) => Field;
                              },
                          >
                          | Readonly<
                              {
                                  get: (state: Field, id: never) => Option<unknown>;
                                  kind: "each";
                                  program: AnyProgram;
                                  set: (state: Field, id: never, child: never) => Field;
                              },
                          >,
                      >,
                  >,
              Model,
              Own = never,
              R = never,
              K = unknown,
          >(
              config: Config<
                  Field<T, "state">,
                  C,
                  Own,
                  Field<T, "command">,
                  Field<T, "event">,
                  Model,
                  R,
                  K,
                  Field<T, "flags">,
              >,
          ) => Shape<
              Field<T, "state">,
              Model,
              Own | ChildMessages<C>,
              Field<T, "command"> | ChildCommands<C>,
              R | ChildServices<C>,
              Field<T, "event">,
              Field<T, "external"> & Own,
              Field<T, "flags">,
          >;
          each: <
              Id,
              P extends
                  Readonly<
                      {
                          init: | Readonly<
                              {
                                  commands?: readonly any[];
                                  events?: readonly never[];
                                  state: any;
                              },
                          >
                          | ((flags: any) => Step<any, any>);
                          makeModel: any;
                          update: any;
                      },
                  >,
          >(
              program: P,
              place: EachPlacement<Field<T, "state">, Id, StateOf<P>> & Readonly<
                  { subscribed: (state: Field) => Iterable<readonly [Id, StateOf<P>]> },
              > & ObjectState<StateOf<P>>,
          ) => Each<State, Id, P>;
      }

    Settings
    Member Visibility