baz<T2>(bar, bazV: T2): T2

Скажи смысл такого типа, а то выглядит очень абстрактно

если я правильно понял, то ни каких проблем с код сплитингом нет, в подключаемых модулях без проблем можно подписаться на сторы

хм.. интересненько

если уйти от абстракции то выходит что то вроде

interface State<T> {
  value: T;
  getters<T2>(value: T, getters: T2): T2;
}

то есть в каждом геттере могут быть использованы все объявленные геттеры
и в итоге выходит что то вроде

export function create<T>(options: State<T>) {
  //
}

const temp1 = create({
  value: {
    x1: 0,
  },
  getters(value, getters) {
    return {
      x1Baz1: () => 200,
      x1Baz2: () => getters.x1Baz1()
    };
  }
});

но тут тоже не совсем корректно getter который параметр в функции getter работает

interface State<T> {
  value: T;
  getters<T2>(value: T, getters: T2): T2;
}

export function create<T>(options: State<T>) {
  //
}

const temp1 = create({
  value: {
    x1: 0,
  },
  getters(value, getters) {
    return {
      x1Baz1: () => 200,
      x1Baz2: () => getters.x1Baz1()
    };
  }
});

Если так, то вроде достаточно прописать getters: T2 в обоих случаях

А возвращаемый тип каждого геттера явно указывать

При вызове

А, нет. Может, стоит сделать объект со всеми геттерами, а не одну функцию, которая эти геттеры возвращает?

getters: {
 bar: ...
 foo: (getters) => (value) => getters.bar + value.foo
}

Либо не делать хитрой передачи геттеров в геттеры, а использовать их напрямую:

const bar = value => value.bar();
const foo = value => value.foo + bar(value);
...
getters: {foo, bar}

что то я не очень понимаю как в итоге выглядит интерфейс который Foo (State)

в таком раскладе

interface Foo<T> {
  foo: T;
  bar<T2>(foo: T, barV: T2): T2;
}

export function create<T>(options: Foo<T>) {}

const temp1 = create({
  foo: { x1: 0 },
  bar(value, getters) {
    getters.x1Get1 = () => 200;
    getters.x1Get2 = () => getters.x1Get1();

    return getters;
  }
});

все вроде норм, автокомплит работает, но выходит ошибка что x1Get1 и x1Get2 не часть T2 что вроде как логично


const create = <T, T2 extends Record<string, (v: T) => unknown>>(value: T, getters: T2): {[g in keyof T2]: ReturnType<T2[g]>};

У функции примерно такой тип должен быть

затащить бы такой плагин в тайпскрипт

Но это если не делать никакого getters.foo(), а использовать геттеры друг в друге напрямую

да

что то у меня явно где то не туда едет

function create<T, T2 extends Record<string, (v: T, g: T2) => any>>(value: T, getters: T2) {
  return {} as any as {[g in keyof T2]: ReturnType<T2[g]>};
}

const temp1 = create({ x1: 0 }, { x1Get1: (v) => v.x1,  x1Get2: (v, g) => g.x1Get1(v) });

даже если примерно так, то в x1Get2 мы не получаем автокомплит для g

function create<T, T2 extends Record<string, (v: T, g: T2) => any>>(value: T, getters: T2) {
  return {} as any as {[g in keyof T2]: ReturnType<T2[g]>};
}

const temp1 = create({ x1: 0 }, { x1Get1: (v) => v.x1,  x1Get2: (v, g) => g.x1Get1(v) });

В x1Get1 второй параметр обязательный вроде