Home/ Questions/Q 1333
Answered
Anonymous
Asked: 2022-02-02T10:11:37+00:00

Typescript: Intellisense autocomplete – custom function as deeply nested object property, that infers it’s argument type from the object property

Basically, I have this type

type X = {
  a: {
    b?: string;
    c?: string;
    d: {
      e:{
        f:{
          g?: boolean
        }
      }
    };
  };
};

// and a helper
const as = <T,>(arg: T):T => arg;

and I need to be able to create an object, in the shape of X where all properties, on all levels of nesting, are replaced by:

as({
    // autocomplete here with actual object property
    // unless it's not an object
})

// like so

const x = as<X>({
  a: as({
    b: as("some string"),
    d: as({
      e: as({
        f: as({
          g: as(false)
        })
      })
    })
  })
})

I got it working to a degree, but at more than 2 levels of nesting, the autocomplete no longer …autocompletes

Please refer to the Typescript playground link for a better understanding of the problem.

typescript
Share

1 Answer

  1. Best Answer

    So… I got it working

    type IsObject<T> = T extends Array<any>
    ? false
    : T extends Date
    ? false
    : T extends object
    ? true
    : false;

type BuiltInFn = "someFn";

type NullableUndefinedOrEmptyUnion = "nullable" | "undefined" | "emptyString";

type Primitive<T> = T extends string
    ? "string"
    : T extends boolean
    ? "boolean"
    : T extends number
    ? "number"
    : never;

type NN<T> = NonNullable<T>;

type S<T, R = T> = IsObject<NN<T>> extends true
    ? {
          // problem remains here, because as soon as properties become optional, types are lost...
          // seems to have something to do with the fact the properties
          // can be undefined, even though i am proxying everything through NonNullable
          [K in keyof T]-?: IsObject<NN<T[K]>> extends false
              ? S<NN<T[K]>, R>
              :
                    | (<XX extends S<NN<T[K]>, R> = S<NN<T[K]>, R>>(value: XX, root: R) => XX)
                    | (<XX extends S<NN<T[K]>, R> = S<NN<T[K]>, R>>(
                          value: (value: XX, root: R) => XX,
                          root: R
                      ) => XX);
      }
    :
          | (<XX extends NN<T> = NN<T>>(
                value: Primitive<XX> extends never ? BuiltInFn : Primitive<XX>,
                root: R
            ) => XX)
          | (<XX extends NN<T> = NN<T>>(value: (value: XX, root: R) => XX, root: R) => XX);

function s<T>(s: S<T, T>): S<T, T> {
    return s;
}

function as<T extends (...args: any) => any>(
    arg: Parameters<T>[0],
    ...opts: Array<BuiltInFn | NullableUndefinedOrEmptyUnion>
): T {
    return arg;
}

type X = {
    a: {
        b: string;
        c?: number;
        d?: {
            nested: {
                e: {
                    f: boolean;
                };
            };
        };
    };
};

const x = s<X>({
    a: as({
        d: as({
            nested: as({
                e: as({
                    f: as("boolean")
                })
            }),
        }),
        b: as("string"),
        c: as("number"),
    }),
});

    Everything is working as expected with one exception I am forced to cast ALL properties to be mandatory, meaning the resulting type cannot have any optional params. Maybe somebody can help with that?

    • 0

Leave an answer

You must login to add an answer.

Need An Account,