Types

Utilities to derive the state, args, deps, and instance shapes of a container class without hand-writing them, plus branded-ID helpers for nominal instance-identity strings. All re-exported from @blac/core (source: types/utilities and types/branded). For a task-oriented walkthrough (generics, inference, typing select) see TypeScript.

A StateContainer (and Cubit) carries three type parameters — S (state), Args (serializable construction/identity data), Deps (injected handles) — extracted from a container class (e.g. typeof CounterCubit), not an instance.

Extraction utilities

Type	Signature	What it’s for	Where you’d use it
ExtractState<T>	T extends StateContainerConstructor<infer S> ? Readonly<S> : never	The state type useBloc and .state return — read-only.	Typing a component prop as “this bloc’s state”.
ExtractStateMutable<T>	Same, without Readonly<>	The raw S as declared.	Building a next-state object before emiting it.
ExtractArgs<T>	T extends new () => StateContainer<any, infer A, any> ? A : void	The serializable Args a bloc is constructed/identified with. Falls back to void.	Typing the args option on useBloc/registry functions.
ExtractDeps<T>	T extends new () => StateContainer<any, any, infer D> ? D : Record<string, never>	The injected non-serializable Deps shape. Falls back to Record<string, never>.	Typing the deps option on useBloc.
ExtractConstructorArgs<T>	T extends new (...args: infer P) => any ? P : never[]	The literal runtime constructor(...) parameter tuple — plain TS inference, not BlaC’s Args.	Rare; typing a wrapper around a class’s real constructor.

import { Cubit } from '@blac/core';
import type { ExtractState, ExtractArgs } from '@blac/core';

class UserCubit extends Cubit<{ name: string }, { userId: string }> {
  constructor() {
    super({ name: '' });
  }
}

type S = ExtractState<typeof UserCubit>; // Readonly<{ name: string }>
type A = ExtractArgs<typeof UserCubit>; //  { userId: string }

Instance and constructor types

Type	Signature	What it’s for	Where you’d use it
StateContainerConstructor<S>	new (...args: any[]) => StateContainer<S, any, any>	Minimal constructor constraint, parameterized by state. No static registry methods.	A helper that only needs “some container class”.
BlocInstanceType<T>	T extends abstract new (...args: any) => infer R ? R : any	Abstract-aware sibling of TS’s built-in InstanceType<T> (which rejects abstract constructors like Cubit/StateContainer).	”The instance type of this class” when the class is abstract.
BlocConstructor<S, T>	(new (...args: any[]) => InstanceType<T>) & { keepAlive?: boolean }	A constructor type with an optional keepAlive static flag. acquire/borrow/ensure/release are standalone functions, not static methods — this type carries no registry surface. Note: the keepAlive field looks unused in practice — isKeepAliveClass reads the class’s static prop directly, not this type field.	Rare; prefer StateContainerConstructor unless you specifically need the keepAlive field.
InstanceReadonlyState<T>	Omit<InstanceType<T>, 'state'> & { state: ExtractState<T> }	The full instance (methods, getters) with state narrowed to Readonly.	The bloc element of useBloc’s return tuple.
InstanceState<T>	Same, with mutable state: ExtractStateMutable<T>	Same, but writable state.	Rare; only when you need a mutable view on a typed instance.
StateContainerInstance<S>	Omit<StateContainer<S, any, any>, 'state'> & { state: Readonly<S> }	”Any container holding this state shape,” keyed by S rather than a concrete class.	Function params that accept any container of a known state shape (e.g. releaseInstance).

import { Cubit } from '@blac/core';
import type { InstanceReadonlyState, StateContainerConstructor } from '@blac/core';

class CounterCubit extends Cubit<{ count: number }> {
  constructor() {
    super({ count: 0 });
  }
}

function describe(Bloc: StateContainerConstructor) {} // "some container class"
declare const c: InstanceReadonlyState<typeof CounterCubit>;
c.state.count; // Readonly<{ count: number }>

Branded IDs (types/branded)

BlaC tags instance-identity strings with a compile-time-only brand so a plain string can’t be passed where a specific branded ID is expected. No runtime footprint — branded values are just strings at runtime.

Export	Signature	What it’s for	Where you’d use it
Brand<T, B>	T & { [brand]: B }	General nominal-typing helper — two Brands with different B are incompatible even when T is identical.	Rolling your own branded primitive type.
BrandedId<B>	Brand<string, B>	Convenience alias for branding a string.	Any string-ID type you want to brand.
InstanceId	Brand<string, 'InstanceId'>	The branded type BlaC’s registry/identity APIs accept and return instead of a bare string.	Typing a parameter that must be an instance ID, not an arbitrary string.
instanceId(id)	(id: string) => InstanceId	Value-level helper that brands a plain string — a pure runtime cast (returns the input unchanged).	Producing an InstanceId without writing as InstanceId yourself.

import { instanceId } from '@blac/core';
import type { InstanceId } from '@blac/core';

declare function lookup(id: InstanceId): void;
lookup(instanceId('user-42')); // ok
lookup('user-42'); // plain string rejected
Error ts(2345)  ― Argument of type 'string' is not assignable to parameter of type 'InstanceId'.
  Type 'string' is not assignable to type '{ [brand]: "InstanceId"; }'.

See also

• TypeScript — typing blocs end to end: generics, inference, pitfalls
• Cubit — the class these utilities extract types from
• Instance Management — acquire/borrow/release, the functions BlocConstructor/StateContainerConstructor type
• Passing Inputs — the args/deps identity model ExtractArgs/ExtractDeps read