在仍能推断类型的同时，能否在此函数中获得TypeScript自动完成功能？

Question

I am writing a set of factory functions, which will each return part of a larger overall object. As it is a complex type, I want to be able to use intellisense to help me write these functions.

I don't know what return type to annotate the functions with to ensure I get intellisense/autocomplete. I have tried three things so far. For these examples, you can assume FooType is defined as:

interface FooType {
    prop1: boolean;
    prop2: boolean;
    ...
}

Option One

I can use type inference to automatically determine type for my functions, but then I don't get any type inference.

function PartialFooMaker1() {
   return {
        prop1: true,
        // I want autocomplete in here
   }
}
function PartialFooMaker2() {
   return {
        prop2: true,
        // I also want autocomplete in here
   }
}

export const Foo: FooType = Object.assign({}, PartialFooMaker1(),PartialFooMaker2());

Option Two

I can specify the full type as the function return type, but that (correctly) triggers a compile error if I omit some properties.

function PartialFooMaker1(): FooType {
   return {
        prop1: true,
        // I have autocomplete, but TS complains about the lack of prop2
   }
}
function PartialFooMaker2(): FooType {
   return {
        prop2: true,
        // I have autocomplete, but TS complains about the lack of prop1
   }
}

export const Foo: FooType = Object.assign({}, PartialFooMaker1(),PartialFooMaker2());

Option Three

I can specify the full type as the function return type, but that (correctly) triggers a compile error if I omit some properties.

function PartialFooMaker1(): Partial<FooType> {
   return {
        prop1: true,
        // I have autocomplete! :)
   }
}
function PartialFooMaker2(): Partial<FooType> {
   return {
        prop2: true,
        // I have autocomplete! :)
   }
}

// the compile error is now here - TS doesn't know that prop1 and prop2 are present
export const Foo: FooType = Object.assign({}, PartialFooMaker1(),PartialFooMaker2());

I have also considered splitting up FooType into well-defined subtypes, and then recombining with union types, but in reality it is a complex derived type, so it would be hard for me to split up.

Is there anything else I can try?

Answer 1

If you can (reasonably) use Pick :

interface NamePart { first: string; last: string }
interface AgePart  { age: number; }
interface FooType extends NamePart, AgePart
{
    oneMoreThing: string;
}

function PartialFooMaker1(): Pick<FooType, keyof NamePart | "oneMoreThing">
{
    return {
        first: "Steve",
        last: "Stevenson",
        oneMoreThing: "!",
    }
}
function PartialFooMaker2(): Pick<FooType, keyof AgePart>
{
    return {
        age: 42
    }
}

export const Foo: FooType = { ...PartialFooMaker1(), ...PartialFooMaker2() };

The first part will have the resolved type Pick<FooType, "first" | "last" | "oneMoreThing"> Pick<FooType, "first" | "last" | "oneMoreThing"> Pick<FooType, "first" | "last" | "oneMoreThing"> which combines correctly with Pick<FooType, "age"> to form a complete instance of FooType .

Keys can be unioned from type-safe literals and keyof expressions.

Answer 2

Partial means zero or more properties in common. What you want is Pick :

function PartialFooMaker1(): Pick<FooType, 'prop1'> {
  return {
       prop1: true,
       // I want autocomplete in here
  };
}

function PartialFooMaker2(): Pick<FooType, 'prop2'> {
  return {
       prop2: true,
       // I also want autocomplete in here
  };
}

Using Pick will require you to provide the properties which you want to pick in advance, but it will give you IntelliSense in return.

Another option would be to tell TypeScript that every factory function returns a piece of FooType .

type Slice<T extends object> = { [P in keyof T]: Pick<T, P> }[keyof T];

type FooFactory = () => Slice<FooType>;

const PartialFooMaker3: FooFactory = () => {
  return {
    prop1: false,
  };
};

This won't require explicit return types, but the inferred type will always be a slice of FooType — not the slice of FooType you are actually returning. That's why I recommend taking the #1 approach. IntelliSense won't suggest what you should return if you don't say what the desired return type should be.