form-graph
    Preparing search index...

    Interface Graph<Ctx, Ext, Defs, W>

    interface Graph<
        Ctx extends object,
        Ext,
        Defs extends Record<string, AnyDef> = Record<never, never>,
        W extends WireMap = Record<never, never>,
    > {
        __wire?: W;
        defs: Defs;
        effects: readonly RuleUnit<any, Ext>[];
        computed<K extends string, T, const E extends string | false = never>(
            key: K & (K extends "_ext" ? never : K),
            calc: (c: DefBag<Ctx, Ext>) => T,
            opts?: { emit?: E },
        ): Graph<
            Ctx & Record<K, T>,
            Ext,
            Defs,
            W & ([E] extends [never] ? Record<never, never> : Record<K, E>),
        >;
        createStore(
            ...args: CreateStoreArgs<Ext>,
        ): FormStore<Ctx, Ext, NormalizeDefs<Defs>, DataOf<Ctx, W>>;
        effect(rules: GraphRules<Ctx, Ext>): Graph<Ctx, Ext, Defs, W>;
        effect(fn: EffectFn<Partial<Ctx>, Ext>): Graph<Ctx, Ext, Defs, W>;
        effect(rules: RuleMap<any, Ext>): Graph<Ctx, Ext, Defs>;
        effect(unit: RuleUnit<any, Ext>): Graph<Ctx, Ext, Defs, W>;
        field<K extends string, const D extends AnyDef | null>(
            key: K & (K extends "_ext" ? never : K),
            def: (c: DefBag<Ctx, Ext>) => D,
        ): Graph<
            Ctx & (
                [Extract<D, null>] extends [never]
                    ? Record<K, DefValue<D>>
                    : Partial<Record<K, DefValue<NonNullable<D>>>>
            ),
            Ext,
            Defs & Record<K, NonNullable<D>>,
            W & (
                [EmitOf<NonNullable<D>>] extends [never]
                    ? Record<never, never>
                    : Record<K, EmitOf<NonNullable<D>>>
            ),
        >;
        field<K extends string, const D extends AnyDef>(
            key: K,
            def: D,
        ): Graph<
            Ctx & Record<K, DefValue<D>>,
            Ext,
            Defs & Record<K, D>,
            W & (
                [EmitOf<D>] extends [never]
                    ? Record<never, never>
                    : Record<K, EmitOf<D>>
            ),
        >;
        parse(
            raw: Record<string, unknown>,
            ...ext: ExtArg<Ext>,
        ): ValidationResult<DataOf<Ctx, W>, Ctx>;
        parsePartial(
            raw: Record<string, unknown>,
            ...ext: ExtArg<Ext>,
        ): {
            data: Partial<DataOf<Ctx, W>>;
            errors: Record<string, FieldError>;
            state: Ctx;
        };
        resolve(f: Fields, ...ext: ExtArg<Ext>): Ctx;
        use<
            C2 extends object,
            X2,
            D2 extends Record<string, AnyDef>,
            W2 extends WireMap,
        >(
            child: NeedsCheck<Ctx & ([Ext] extends [object] ? Ext : unknown), X2> & GraphSource<
                C2,
                X2,
                D2,
                W2,
            >,
        ): Graph<Ctx & C2, Ext, Defs & D2, W & W2>;
        use<G>(fn: (g: this) => G): G;
    }

    Type Parameters

    • Ctx extends object
    • Ext
    • Defs extends Record<string, AnyDef> = Record<never, never>
    • W extends WireMap = Record<never, never>

    Hierarchy

    Index
    __wire? defs effects
    computed createStore effect field parse parsePartial resolve use

    Optional Readonly__wire

    __wire?: W

    PHANTOM — never set at runtime. Carries the wire map in the type so composition sites (.use, hub members) can INFER it; without a member mentioning W, inference has no site and falls back to the constraint, whose keyof is string — which would Omit every key from DataOf.

    defs: Defs

    The registry for bindings and forms. TYPE-complete (every field, function-defined ones included, so typedFields/<Field> know every key); at RUNTIME it holds the static defs only — resolution always passes the freshly computed def, so nothing reads the runtime entries for function fields.

    effects: readonly RuleUnit<any, Ext>[]

    • Type Parameters

      • K extends string
      • T
      • const E extends string | false = never

      Parameters

      • key: K & (K extends "_ext" ? never : K)
      • calc: (c: DefBag<Ctx, Ext>) => T
      • Optionalopts: { emit?: E }

      Returns Graph<
          Ctx & Record<K, T>,
          Ext,
          Defs,
          W & ([E] extends [never] ? Record<never, never> : Record<K, E>),
      >

    • Type Parameters

      • K extends string
      • const D extends AnyDef | null

      Parameters

      • key: K & (K extends "_ext" ? never : K)
      • def: (c: DefBag<Ctx, Ext>) => D

      Returns Graph<
          Ctx & (
              [Extract<D, null>] extends [never]
                  ? Record<K, DefValue<D>>
                  : Partial<Record<K, DefValue<NonNullable<D>>>>
          ),
          Ext,
          Defs & Record<K, NonNullable<D>>,
          W & (
              [EmitOf<NonNullable<D>>] extends [never]
                  ? Record<never, never>
                  : Record<K, EmitOf<NonNullable<D>>>
          ),
      >

    • Type Parameters

      • K extends string
      • const D extends AnyDef

      Parameters

      • key: K
      • def: D

      Returns Graph<
          Ctx & Record<K, DefValue<D>>,
          Ext,
          Defs & Record<K, D>,
          W & (
              [EmitOf<D>] extends [never]
                  ? Record<never, never>
                  : Record<K, EmitOf<D>>
          ),
      >

    • Best-effort parse: valid fields plus the errors, no throw.

      Parameters

      • raw: Record<string, unknown>
      • ...ext: ExtArg<Ext>

      Returns {
          data: Partial<DataOf<Ctx, W>>;
          errors: Record<string, FieldError>;
          state: Ctx;
      }

    • Mount another graph (or hub) at this point in the chain. The child is an ordinary defineGraph whose Ext declares what it NEEDS from upstream — at resolve time it receives the parent's ext with the ctx-so-far merged over it, so a need is satisfied by a prior field or by the parent's own ext. Its fields, registry, and effects join the chain.

      The function form is plain application — use(fn) IS fn(this) — for transforms a standalone graph can't express (e.g. key prefixing).

      Type Parameters

      • C2 extends object
      • X2
      • D2 extends Record<string, AnyDef>
      • W2 extends WireMap

      Parameters

      Returns Graph<Ctx & C2, Ext, Defs & D2, W & W2>

    • Type Parameters

      • G

      Parameters

      • fn: (g: this) => G

      Returns G

    Settings
    Member Visibility

    On This Page
    Properties
    Methods