Documentation navigation

Published API · 0.1.0-rc.1

foldkit · update

Published foldkit API declarations for update.

./update

@wsagency/wseffect-foldkit · MIT · source · MIT license · WS-AGENCY-NOTICE · THIRD-PARTY-NOTICES

This entry point is published in @wsagency/wseffect-foldkit@0.1.0-rc.1. Import it from the package subpath shown below; the signatures and documentation are read from the installed package declarations.

import * as Wseffect from '@wsagency/wseffect-foldkit/update'

Exported declarations

ChildFold

The four capabilities that fold one child Submodel's update into the parent, for a child whose update cannot emit an OutMessage. - `update`: the child update function to run. - `read`: the getter half of the lens onto the child: reads the child Model from the parent Model. Returns an `Option` because a child may not be mounted (for example a page behind a route or a keyed collection miss); a single always-present field wraps in `Option.some`. - `write`: the setter half of the lens: writes the updated child Model back into the parent Model. - `toParentMessage`: lifts a child Message into the parent's Message, the same contract `h.submodel` takes for the view half. Always the child's `Got*` wrapper: `message => GotSearchMessage({ message })`.

export type ChildFold<ParentModel, ParentMessage, ChildModel, Input, ChildMessage, R = never> = Readonly<{
    update: (childModel: ChildModel, input: Input) => Return<ChildModel, ChildMessage, R>;
    read: (model: ParentModel) => Option.Option<ChildModel>;
    write: (model: ParentModel, nextChildModel: ChildModel) => ParentModel;
    toParentMessage: (message: ChildMessage) => ParentMessage;
}>;

ChildFoldAt

export type ChildFoldAt<ParentModel, ParentMessage, ChildModel, Key, Input, ChildMessage, R = never> = Readonly<{
    update: (childModel: ChildModel, input: Input) => Return<ChildModel, ChildMessage, R>;
    readAt: (model: ParentModel, key: Key) => Option.Option<ChildModel>;
    writeAt: (model: ParentModel, key: Key, nextChildModel: ChildModel) => ParentModel;
    toParentMessage: (key: Key, message: ChildMessage) => ParentMessage;
}>;

ChildFoldAtWithDerivedParentOutMessage

export type ChildFoldAtWithDerivedParentOutMessage<ParentModel, ParentMessage, ChildModel, Key, Input, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage> = Readonly<{
    update: (childModel: ChildModel, input: Input) => ReturnWithOutMessage<ChildModel, ChildMessage, ChildOutMessage, ChildRequirements>;
    readAt: (model: ParentModel, key: Key) => Option.Option<ChildModel>;
    writeAt: (model: ParentModel, key: Key, nextChildModel: ChildModel) => ParentModel;
    toParentMessage: (key: Key, message: ChildMessage) => ParentMessage;
    toParentOutMessage?: never;
    foldOutMessage: (key: Key, context: FoldContext<ChildMessage, ParentMessage>) => (outMessage: ChildOutMessage) => StepWithOutMessage<NoInfer<ParentModel>, OutMessageStepMessage, ParentOutMessage, OutMessageStepRequirements>;
}>;

ChildFoldAtWithOutMessage

export type ChildFoldAtWithOutMessage<ParentModel, ParentMessage, ChildModel, Key, Input, ChildMessage, ChildOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage> = Readonly<{
    update: (childModel: ChildModel, input: Input) => ReturnWithOutMessage<ChildModel, ChildMessage, ChildOutMessage, ChildRequirements>;
    readAt: (model: ParentModel, key: Key) => Option.Option<ChildModel>;
    writeAt: (model: ParentModel, key: Key, nextChildModel: ChildModel) => ParentModel;
    toParentMessage: (key: Key, message: ChildMessage) => ParentMessage;
    foldOutMessage: (key: Key, context: FoldContext<ChildMessage, ParentMessage>) => (outMessage: ChildOutMessage) => Step<NoInfer<ParentModel>, OutMessageStepMessage, OutMessageStepRequirements>;
}>;

ChildFoldAtWithParentOutMessage

export type ChildFoldAtWithParentOutMessage<ParentModel, ParentMessage, ChildModel, Key, Input, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage, DerivedParentOutMessage = ParentOutMessage> = Readonly<{
    update: (childModel: ChildModel, input: Input) => ReturnWithOutMessage<ChildModel, ChildMessage, ChildOutMessage, ChildRequirements>;
    readAt: (model: ParentModel, key: Key) => Option.Option<ChildModel>;
    writeAt: (model: ParentModel, key: Key, nextChildModel: ChildModel) => ParentModel;
    toParentMessage: (key: Key, message: ChildMessage) => ParentMessage;
    toParentOutMessage: (key: Key) => (outMessage: ChildOutMessage) => ParentOutMessage | undefined;
    foldOutMessage?: (key: Key, context: FoldContext<ChildMessage, ParentMessage>) => (outMessage: ChildOutMessage) => StepWithOutMessage<NoInfer<ParentModel>, OutMessageStepMessage, DerivedParentOutMessage, OutMessageStepRequirements>;
}>;

ChildFoldWithDerivedParentOutMessage

export type ChildFoldWithDerivedParentOutMessage<ParentModel, ParentMessage, ChildModel, Input, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage> = Readonly<{
    update: (childModel: ChildModel, input: Input) => ReturnWithOutMessage<ChildModel, ChildMessage, ChildOutMessage, ChildRequirements>;
    read: (model: ParentModel) => Option.Option<ChildModel>;
    write: (model: ParentModel, nextChildModel: ChildModel) => ParentModel;
    toParentMessage: (message: ChildMessage) => ParentMessage;
    toParentOutMessage?: never;
    foldOutMessage: (outMessage: ChildOutMessage, context: FoldContext<ChildMessage, ParentMessage>) => StepWithOutMessage<NoInfer<ParentModel>, OutMessageStepMessage, ParentOutMessage, OutMessageStepRequirements>;
}>;

ChildFoldWithOutMessage

export type ChildFoldWithOutMessage<ParentModel, ParentMessage, ChildModel, Input, ChildMessage, ChildOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage> = Readonly<{
    update: (childModel: ChildModel, input: Input) => ReturnWithOutMessage<ChildModel, ChildMessage, ChildOutMessage, ChildRequirements>;
    read: (model: ParentModel) => Option.Option<ChildModel>;
    write: (model: ParentModel, nextChildModel: ChildModel) => ParentModel;
    toParentMessage: (message: ChildMessage) => ParentMessage;
    foldOutMessage: (outMessage: ChildOutMessage, context: FoldContext<ChildMessage, ParentMessage>) => Step<NoInfer<ParentModel>, OutMessageStepMessage, OutMessageStepRequirements>;
}>;

ChildFoldWithParentOutMessage

export type ChildFoldWithParentOutMessage<ParentModel, ParentMessage, ChildModel, Input, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage, DerivedParentOutMessage = ParentOutMessage> = Readonly<{
    update: (childModel: ChildModel, input: Input) => ReturnWithOutMessage<ChildModel, ChildMessage, ChildOutMessage, ChildRequirements>;
    read: (model: ParentModel) => Option.Option<ChildModel>;
    write: (model: ParentModel, nextChildModel: ChildModel) => ParentModel;
    toParentMessage: (message: ChildMessage) => ParentMessage;
    toParentOutMessage: (outMessage: ChildOutMessage) => ParentOutMessage | undefined;
    foldOutMessage?: (outMessage: ChildOutMessage, context: FoldContext<ChildMessage, ParentMessage>) => StepWithOutMessage<NoInfer<ParentModel>, OutMessageStepMessage, DerivedParentOutMessage, OutMessageStepRequirements>;
}>;

ChildStepFold

export type ChildStepFold<ParentModel, ParentMessage, ChildModel, ChildMessage, R = never> = Readonly<{
    update: (childModel: ChildModel) => Return<ChildModel, ChildMessage, R>;
    read: (model: ParentModel) => Option.Option<ChildModel>;
    write: (model: ParentModel, nextChildModel: ChildModel) => ParentModel;
    toParentMessage: (message: ChildMessage) => ParentMessage;
}>;

ChildStepFoldWithDerivedParentOutMessage

export type ChildStepFoldWithDerivedParentOutMessage<ParentModel, ParentMessage, ChildModel, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage> = Readonly<{
    update: (childModel: ChildModel) => ReturnWithOutMessage<ChildModel, ChildMessage, ChildOutMessage, ChildRequirements>;
    read: (model: ParentModel) => Option.Option<ChildModel>;
    write: (model: ParentModel, nextChildModel: ChildModel) => ParentModel;
    toParentMessage: (message: ChildMessage) => ParentMessage;
    toParentOutMessage?: never;
    foldOutMessage: (outMessage: ChildOutMessage, context: FoldContext<ChildMessage, ParentMessage>) => StepWithOutMessage<NoInfer<ParentModel>, OutMessageStepMessage, ParentOutMessage, OutMessageStepRequirements>;
}>;

ChildStepFoldWithOutMessage

export type ChildStepFoldWithOutMessage<ParentModel, ParentMessage, ChildModel, ChildMessage, ChildOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage> = Readonly<{
    update: (childModel: ChildModel) => ReturnWithOutMessage<ChildModel, ChildMessage, ChildOutMessage, ChildRequirements>;
    read: (model: ParentModel) => Option.Option<ChildModel>;
    write: (model: ParentModel, nextChildModel: ChildModel) => ParentModel;
    toParentMessage: (message: ChildMessage) => ParentMessage;
    foldOutMessage: (outMessage: ChildOutMessage, context: FoldContext<ChildMessage, ParentMessage>) => Step<NoInfer<ParentModel>, OutMessageStepMessage, OutMessageStepRequirements>;
}>;

ChildStepFoldWithParentOutMessage

export type ChildStepFoldWithParentOutMessage<ParentModel, ParentMessage, ChildModel, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage, DerivedParentOutMessage = ParentOutMessage> = Readonly<{
    update: (childModel: ChildModel) => ReturnWithOutMessage<ChildModel, ChildMessage, ChildOutMessage, ChildRequirements>;
    read: (model: ParentModel) => Option.Option<ChildModel>;
    write: (model: ParentModel, nextChildModel: ChildModel) => ParentModel;
    toParentMessage: (message: ChildMessage) => ParentMessage;
    toParentOutMessage: (outMessage: ChildOutMessage) => ParentOutMessage | undefined;
    foldOutMessage?: (outMessage: ChildOutMessage, context: FoldContext<ChildMessage, ParentMessage>) => StepWithOutMessage<NoInfer<ParentModel>, OutMessageStepMessage, DerivedParentOutMessage, OutMessageStepRequirements>;
}>;

combine

combine: {
    <Model, Message, R = never>(steps: ReadonlyArray<Step<Model, Message, R>>): Step<Model, Message, R>;
    <Model, Message, R = never>(model: Model, steps: ReadonlyArray<Step<Model, Message, R>>): Return<Model, Message, R>;
}

Commands

The Commands collection an update return may include. The collection keeps the order in which the update returned them, but the runtime forks the Commands independently. `R` is the services the Commands need and defaults to `never` for applications without resources. Name an alias when a module reuses the same Message and service types: ```ts export type Commands = Update.Commands<Message, AppServices> ```

export type Commands<Message, R = never> = ReadonlyArray<Command<Message, never, R>>;

Fold

export type Fold<ParentModel, ParentMessage, Input, R = never> = {
    (model: ParentModel, input: Input): Return<ParentModel, ParentMessage, R>;
    (input: Input): Step<ParentModel, ParentMessage, R>;
};

FoldAt

export type FoldAt<ParentModel, ParentMessage, Key, Input, R = never> = {
    (model: ParentModel, key: Key, input: Input): Return<ParentModel, ParentMessage, R>;
    (key: Key, input: Input): Step<ParentModel, ParentMessage, R>;
};

FoldAtWithOutMessage

export type FoldAtWithOutMessage<ParentModel, ParentMessage, Key, Input, ParentOutMessage, R = never> = {
    (model: ParentModel, key: Key, input: Input): ReturnWithOutMessage<ParentModel, ParentMessage, ParentOutMessage, R>;
    (key: Key, input: Input): StepWithOutMessage<ParentModel, ParentMessage, ParentOutMessage, R>;
};

foldChild

foldChild: {
    <ParentModel, ParentMessage, ChildModel, Input, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage, DerivedParentOutMessage = ParentOutMessage>(childFold: ChildFoldWithParentOutMessage<ParentModel, ParentMessage, ChildModel, Input, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements, OutMessageStepRequirements, OutMessageStepMessage, DerivedParentOutMessage>): FoldWithOutMessage<ParentModel, ParentMessage | OutMessageStepMessage, Input, ParentOutMessage | DerivedParentOutMessage, ChildRequirements | OutMessageStepRequirements>;
    <ParentModel, ParentMessage, ChildModel, Input, ChildMessage, ChildOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage>(childFold: ChildFoldWithOutMessage<ParentModel, ParentMessage, ChildModel, Input, ChildMessage, ChildOutMessage, ChildRequirements, OutMessageStepRequirements, OutMessageStepMessage>): Fold<ParentModel, ParentMessage | OutMessageStepMessage, Input, ChildRequirements | OutMessageStepRequirements>;
    <ParentModel, ParentMessage, ChildModel, Input, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage>(childFold: ChildFoldWithDerivedParentOutMessage<ParentModel, ParentMessage, ChildModel, Input, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements, OutMessageStepRequirements, OutMessageStepMessage>): FoldWithOutMessage<ParentModel, ParentMessage | OutMessageStepMessage, Input, ParentOutMessage, ChildRequirements | OutMessageStepRequirements>;
    <ParentModel, ParentMessage, ChildModel, Input, ChildMessage, R = never>(childFold: ChildFold<ParentModel, ParentMessage, ChildModel, Input, ChildMessage, R>): Fold<ParentModel, ParentMessage, Input, R>;
}

foldChildAt

foldChildAt: {
    <ParentModel, ParentMessage, ChildModel, Input, ChildMessage, ChildOutMessage, ParentOutMessage, Key, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage, DerivedParentOutMessage = ParentOutMessage>(childFold: ChildFoldAtWithParentOutMessage<ParentModel, ParentMessage, ChildModel, Key, Input, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements, OutMessageStepRequirements, OutMessageStepMessage, DerivedParentOutMessage>): FoldAtWithOutMessage<ParentModel, ParentMessage | OutMessageStepMessage, Key, Input, ParentOutMessage | DerivedParentOutMessage, ChildRequirements | OutMessageStepRequirements>;
    <ParentModel, ParentMessage, ChildModel, Input, ChildMessage, ChildOutMessage, Key, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage>(childFold: ChildFoldAtWithOutMessage<ParentModel, ParentMessage, ChildModel, Key, Input, ChildMessage, ChildOutMessage, ChildRequirements, OutMessageStepRequirements, OutMessageStepMessage>): FoldAt<ParentModel, ParentMessage | OutMessageStepMessage, Key, Input, ChildRequirements | OutMessageStepRequirements>;
    <ParentModel, ParentMessage, ChildModel, Input, ChildMessage, ChildOutMessage, ParentOutMessage, Key, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage>(childFold: ChildFoldAtWithDerivedParentOutMessage<ParentModel, ParentMessage, ChildModel, Key, Input, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements, OutMessageStepRequirements, OutMessageStepMessage>): FoldAtWithOutMessage<ParentModel, ParentMessage | OutMessageStepMessage, Key, Input, ParentOutMessage, ChildRequirements | OutMessageStepRequirements>;
    <ParentModel, ParentMessage, ChildModel, Input, ChildMessage, Key, R = never>(childFold: ChildFoldAt<ParentModel, ParentMessage, ChildModel, Key, Input, ChildMessage, R>): FoldAt<ParentModel, ParentMessage, Key, Input, R>;
}

foldChildInit

foldChildInit: {
    <ParentModel, ParentMessage, ChildModel, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage, DerivedParentOutMessage = ParentOutMessage>(childInit: ReturnWithOutMessage<ChildModel, ChildMessage, ChildOutMessage, ChildRequirements>, childFold: Readonly<{
        toParentModel: (childModel: ChildModel) => ParentModel;
        toParentMessage: (message: ChildMessage) => ParentMessage;
        toParentOutMessage: (outMessage: ChildOutMessage) => ParentOutMessage | undefined;
        foldOutMessage?: (outMessage: ChildOutMessage, context: FoldContext<ChildMessage, ParentMessage>) => StepWithOutMessage<ParentModel, OutMessageStepMessage, DerivedParentOutMessage, OutMessageStepRequirements>;
    }>): ReturnWithOutMessage<ParentModel, ParentMessage | OutMessageStepMessage, ParentOutMessage | DerivedParentOutMessage, ChildRequirements | OutMessageStepRequirements>;
    <ParentModel, ParentMessage, ChildModel, ChildMessage, ChildOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage>(childInit: ReturnWithOutMessage<ChildModel, ChildMessage, ChildOutMessage, ChildRequirements>, childFold: Readonly<{
        toParentModel: (childModel: ChildModel) => ParentModel;
        toParentMessage: (message: ChildMessage) => ParentMessage;
        foldOutMessage: (outMessage: ChildOutMessage, context: FoldContext<ChildMessage, ParentMessage>) => Step<ParentModel, OutMessageStepMessage, OutMessageStepRequirements>;
    }>): Return<ParentModel, ParentMessage | OutMessageStepMessage, ChildRequirements | OutMessageStepRequirements>;
    <ParentModel, ParentMessage, ChildModel, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage>(childInit: ReturnWithOutMessage<ChildModel, ChildMessage, ChildOutMessage, ChildRequirements>, childFold: Readonly<{
        toParentModel: (childModel: ChildModel) => ParentModel;
        toParentMessage: (message: ChildMessage) => ParentMessage;
        toParentOutMessage?: never;
        foldOutMessage: (outMessage: ChildOutMessage, context: FoldContext<ChildMessage, ParentMessage>) => StepWithOutMessage<ParentModel, OutMessageStepMessage, ParentOutMessage, OutMessageStepRequirements>;
    }>): ReturnWithOutMessage<ParentModel, ParentMessage | OutMessageStepMessage, ParentOutMessage, ChildRequirements | OutMessageStepRequirements>;
    <ParentModel, ParentMessage, ChildModel, ChildMessage, R = never>(childInit: Return<ChildModel, ChildMessage, R>, childFold: Readonly<{
        toParentModel: (childModel: ChildModel) => ParentModel;
        toParentMessage: (message: ChildMessage) => ParentMessage;
    }>): Return<ParentModel, ParentMessage, R>;
}

foldChildInits

foldChildInits: <ChildInits extends Readonly<Record<PropertyKey, AnyUpdateReturn>>, ToParentModel extends (models: {
    readonly [Key in keyof ChildInits]: ChildInits[Key]['model'];
}) => any, Folds extends {
    readonly [Key in keyof ChildInits]: unknown;
}, ParentOutMessage = never>(childInits: ChildInits, configuration: Readonly<{
    toParentModel: ToParentModel;
    folds: Folds & {
        readonly [Key in keyof ChildInits]: InitFold<ChildInits[Key], ReturnType<ToParentModel>>;
    } & Record<Exclude<keyof Folds, keyof ChildInits>, never> & NoInfer<{
        readonly [Key in keyof ChildInits]: InitFoldValidation<ChildInits[Key], ReturnType<ToParentModel>, Folds[Key]>;
    }>;
}> & {
    resolveOutMessage?: (outMessages: InitOutMessages<Folds>, model: ReturnType<ToParentModel>) => ParentOutMessage | undefined;
} & NoInfer<InitResolution<Folds>>) => unknown extends Folds[keyof Folds] ? ReturnWithOutMessage<ReturnType<ToParentModel>, unknown, unknown, unknown> : [InitParentOutMessage<Folds[keyof Folds]>] extends [never] ? Return<ReturnType<ToParentModel>, InitMessages<Folds>, InitRequirements<ChildInits, Folds>> : ReturnWithOutMessage<ReturnType<ToParentModel>, InitMessages<Folds>, ParentOutMessage, InitRequirements<ChildInits, Folds>>

foldChildStep

foldChildStep: {
    <ParentModel, ParentMessage, ChildModel, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage, DerivedParentOutMessage = ParentOutMessage>(childFold: ChildStepFoldWithParentOutMessage<ParentModel, ParentMessage, ChildModel, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements, OutMessageStepRequirements, OutMessageStepMessage, DerivedParentOutMessage>): StepWithOutMessage<ParentModel, ParentMessage | OutMessageStepMessage, ParentOutMessage | DerivedParentOutMessage, ChildRequirements | OutMessageStepRequirements>;
    <ParentModel, ParentMessage, ChildModel, ChildMessage, ChildOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage>(childFold: ChildStepFoldWithOutMessage<ParentModel, ParentMessage, ChildModel, ChildMessage, ChildOutMessage, ChildRequirements, OutMessageStepRequirements, OutMessageStepMessage>): Step<ParentModel, ParentMessage | OutMessageStepMessage, ChildRequirements | OutMessageStepRequirements>;
    <ParentModel, ParentMessage, ChildModel, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements = never, OutMessageStepRequirements = ChildRequirements, OutMessageStepMessage = ParentMessage>(childFold: ChildStepFoldWithDerivedParentOutMessage<ParentModel, ParentMessage, ChildModel, ChildMessage, ChildOutMessage, ParentOutMessage, ChildRequirements, OutMessageStepRequirements, OutMessageStepMessage>): StepWithOutMessage<ParentModel, ParentMessage | OutMessageStepMessage, ParentOutMessage, ChildRequirements | OutMessageStepRequirements>;
    <ParentModel, ParentMessage, ChildModel, ChildMessage, R = never>(childFold: ChildStepFold<ParentModel, ParentMessage, ChildModel, ChildMessage, R>): Step<ParentModel, ParentMessage, R>;
}

FoldContext

The lifters a `foldOutMessage` receives as its second parameter, already bound to the fold config's `toParentMessage`. The fold already lifts the Commands returned by the child's `update`. Use these lifters for a Command returned by the parent's OutMessage Step when that Command still produces the child's Message. For example, the parent may handle a child's `Requested*` fact by returning a child Command built with routing context only the parent holds. The lifters apply the same lift the fold gives the child's own Commands, so the Step writes no `Command.mapMessage` call and keeps no second copy of the wrapper, and the mapping stays recorded on the Command for `Story.Command.resolve` and `Scene.Command.resolve`. The annotated standalone const takes both parameters, so pass the OutMessage value to its union matcher: ```ts const foldLoginOutMessage = ( outMessage: Login.OutMessage, { liftCommand }: Update.FoldContext<Login.Message, Message>, ) => Login.OutMessage.match<Update.Step<Model, Message>>(outMessage, { RequestedMagicLink: ({ email }) => model => ({ model, commands: [ liftCommand( Login.SendMagicLink({ email, redirectRoute: model.route }), ), ], }), }) ```

export type FoldContext<ChildMessage, ParentMessage> = Readonly<{
    liftCommand: <E = never, R = never>(command: Command<ChildMessage, E, R>) => Command<ParentMessage, E, R>;
    liftCommands: <E = never, R = never>(commands: ReadonlyArray<Command<ChildMessage, E, R>>) => ReadonlyArray<Command<ParentMessage, E, R>>;
}>;

FoldWithOutMessage

export type FoldWithOutMessage<ParentModel, ParentMessage, Input, ParentOutMessage, R = never> = {
    (model: ParentModel, input: Input): ReturnWithOutMessage<ParentModel, ParentMessage, ParentOutMessage, R>;
    (input: Input): StepWithOutMessage<ParentModel, ParentMessage, ParentOutMessage, R>;
};

refresh

refresh: <Model, Message, A, E, R = never>(refreshable: Refreshable<Model, Message, A, E, R>) => Step<Model, Message, R>

Refreshable

The four capabilities that make one cache field revalidatable. - `read`: gets the field's AsyncData out of the Model. Returns an `Option` because keyed caches miss (`HashMap.get`); single fields wrap in `Option.some`. - `revalidate`: decides whether and how the entry transitions. Usually exactly `AsyncData.revalidate` (refresh after a mutation: only `Success` and `Stale` move to `Refreshing`). Pass `AsyncData.revalidateOrLoad` instead for load-on-entry semantics. - `write`: puts the transitioned entry back into the Model. - `load`: the Command that refetches the data.

export type Refreshable<Model, Message, A, E, R = never> = Readonly<{
    read: (model: Model) => Option.Option<AsyncData<A, E>>;
    revalidate: (current: AsyncData<A, E>) => Option.Option<AsyncData<A, E>>;
    write: (model: Model, next: AsyncData<A, E>) => Model;
    load: Command<Message, never, R>;
}>;

Return

The record an update returns when it cannot emit an OutMessage: the next Model and any Commands to run. Inline the type when a matcher is its only use: ```ts export const update = (model: Model, message: Message) => Message.match<Update.Return<Model, Message>>(message, { ClickedSave: () => ({ model, commands: [Save()] }), SucceededSave: ({ note }) => ({ model: modifyFields(model, { note: () => note }), }), }) ``` Give it a local `UpdateReturn` alias when another matcher or helper in the module needs the same type.

export type Return<Model, Message, R = never> = Readonly<{
    model: Model;
    commands?: Commands<Message, R>;
    /** This result emits no OutMessage. The field may be omitted but cannot hold
     *  a value. TypeScript therefore rejects a result containing an OutMessage
     *  where a caller would keep only the Model and Commands. */
    outMessage?: never;
}>;

ReturnWithOutMessage

export type ReturnWithOutMessage<Model, Message, OutMessage, R = never> = Readonly<{
    model: Model;
    commands?: Commands<Message, R>;
    outMessage?: OutMessage;
}>;

Step

export type Step<Model, Message, R = never> = (model: Model) => Return<Model, Message, R>;

StepWithOutMessage

export type StepWithOutMessage<Model, Message, OutMessage, R = never> = (model: Model) => ReturnWithOutMessage<Model, Message, OutMessage, R>;

withOutMessage

withOutMessage: {
    <OutMessage>(outMessage: OutMessage | undefined): <Model, Message, R = never>(updateReturn: Return<Model, Message, R>) => ReturnWithOutMessage<Model, Message, OutMessage, R>;
    <Model, Message, OutMessage, R = never>(updateReturn: Return<Model, Message, R>, outMessage: OutMessage | undefined): ReturnWithOutMessage<Model, Message, OutMessage, R>;
}