которой можно прокидывать дефолтные пропы в функцию:
                  
                  
                  
                  
                  
                  type Function<T> = (props: T) => string;
                  
                  
                  
                  
                  
                  type PartialType<T extends P, P> = Omit<T, keyof P> & Partial<Pick<T, keyof P>>
                  
                  
                  
                  
                  
                  const pass = <T extends {}>(passProps: T) => {
                  
                  
                    return <P extends T>(foo: Foo.Function<P>) => {
                  
                  
                      return (fooProps: PartialType<P, T>) => {
                  
                  
                        return foo({ ...passProps, ...fooProps } as P);
                  
                  
                      };
                  
                  
                    };
                  
                  
                  };
                  
                  
                  
                  
                  
                  на выходе мы получаем ту же самую функцию, но с немного другим типом пропсов - PartialType в качестве первого аргумента получает тип пропсов компонента, в качестве второго аргумента — тип прокидываемых значений, и делает их необязательными в типе пропсов компонента. Таки образом:
                  
                  
                  
                  
                  
                  type OwnProps = {
                  
                  
                    name: string;
                  
                  
                  };
                  
                  
                  
                  
                  
                  type AdditionalProps = {
                  
                  
                    age: number;
                  
                  
                  };
                  
                  
                  
                  
                  
                  type Props = OwnProps & AdditionalProps;
                  
                  
                  
                  
                  
                  const foo: Foo.Function<Foo.Props> = ({ name, age }) => {
                  
                  
                    return `My name is ${name}, I'm ${age} y. o.`;
                  
                  
                  };
                  
                  
                  
                  
                  
                  const newFoo1 = pass({})(foo); 
                  
                  
                  // typeof newFoo1: (fooProps: PartialType<
                  
                  
                  //   Foo.Props, 
                  
                  
                  //   {}
                  
                  
                  // >) => string
                  
                  
                  // или fooProps: Foo.Props
                  
                  
                  
                  
                  
                  const newFoo2 = pass({age: 20})(foo); 
                  
                  
                  // typeof newFoo2: (fooProps: PartialType<
                  
                  
                  //   Foo.Props, 
                  
                  
                  //   {age: number;}
                  
                  
                  // >) => string
                  
                  
                  // или fooProps: {name: string; age?: number;}
                  
                  
                  
                  
                  
                  Ну а дальше начинается дичь:
                  
                  
                  
                  
                  
                  const newFoo3 = pass({age: 20, bla: 'bla'})(foo); 
                  
                  
                  // typeof newFoo3: (fooProps: PartialType<
                  
                  
                  //   {name: string; bla: string;}, - почему не Foo.Props?
                  
                  
                  //   {name: string; bla: string;}
                  
                  
                  // >) => string
                  
                  
                  
                  
                  
                  Почему тип пропсов компонента вдруг стал равен типу того, что мы прокидываем в pass? Как это чинится?
                  
                  
                
Плейграунд: https://codesandbox.io/s/vigilant-rubin-9-5p3bt?file=/src/index.ts
Подожди, у тебя же return <P extends T>(foo: Foo.Function<P>) => { В аргументе функции обязаны быть все свойства, что есть в "дефолтном" объекте
Обсуждают сегодня