Typescript: type assist for function argument

Question

I've written a little library and now I'm trying to add type support for it through creating custom d.ts files.

To give an example (my library is called layerCompose):

const C = layerCompose(
  {
     _($) { /* function body */ },
     execute($) { /* function body */ }
  }
)
const c = C()
c._()

You will notice that both _ and execute function take a parameter $. This parameter (in our example) is an object with _ and execute properties (similar to this within a class)

So, I'd like to add type support to this $ parameter. Through experimenting I found that having this definition inside my d.ts file gives type support within the _ function.

export function layerCompose<
  T extends [
    A extends {} 
      ? {
        _($: {test: () => void})
      } 
      : never
  ]
  , A
>(...layers: T): lcConstructor<Spread<T>>

In other words Webstorm can see that $ parameter in _ function has type {test: () => void}

Obviously, that's not what I'm looking for. However, changing the signature to (what seems proper to me)

export function layerCompose<
  T extends [
    A extends {} 
      ? { 
        [K in keyof A]: ($: {test: () => void}) => any 
      } 
      : never
  ]
  , A
>(...layers: T): lcConstructor<Spread<T>>

and Webstorm looses the ability to tell that $ is an object with properties _ and execute.

EDIT: Included an example on typescript playground. It's missing the return type (non-trivial to set that up quickly), but otherwise gives an insight into what layerCompose approximately does.

EDIT 2:

Playing around further, having simplified to 1 parameter scenario, this works:

export function layerCompose<L1>(l1: {_: ($: {test: () => void}) => void} & L1): void

yet this does not:

export function layerCompose<L1>(l1: {[K in keyof L1]: ($: {test: () => void}) => void} & L1): void

How is A being resolved and why is it unused in the function signature? You should write a fully reproducible example of your problem. typescriptlang.org/play would be welcome — Guerric P
– Guerric P, Commented Dec 7, 2021 at 18:47
The examples you've provided for typing layerCompose always results in T = never. Are you sure they are being used? Webstorm might not be recognizing your declaration files correctly. — Olian04
– Olian04, Commented Dec 7, 2021 at 23:31
@Olian04 I've been fairly diligent at making sure that updates to my d.ts files are propagated. I can see when Webstorm picks up the signatures and when it fails as I experiment. — Anton
– Anton, Commented Dec 8, 2021 at 2:18

Olian04 · Accepted Answer · 2021-12-07 23:40:36Z

2

Is this what you're looking for?

export function layerCompose(...layers: Layer[]): lcConstructor<Spread<T>>;

Since you haven't defined neither lcConstructor or Spread I can't make any real guesses as to what the return type of layerCompose is supposed to be. So for the purpose of this answer those types have been replaced with the identity type.

// See playground below
type ComposedLayer = {
  _(): void;
  execute(): void;
}
type Layer = {
  _(v: Layer): void;
  execute(v: Layer): void;
}

/* dummy type */ type lcConstructor<T> = ComposedLayer;
/* dummy type */ type Spread<T> = T;

declare function layerCompose(...layers: Layer[]): lcConstructor<Spread<Layer>>;

const C = layerCompose(
  {
     _($) {},
     execute($) {
       $._({
         _($) {},
         execute($) {}
       })
     }
  }
);

C._();

playground

answered Dec 7, 2021 at 23:40

Olian04

6,9002 gold badges31 silver badges56 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Anton Over a year ago

Take a look at the playground example that I provided. The trouble is that I don't know the shape of Layer ahead of time.

chinesedfan · Accepted Answer · 2021-12-15 08:44:33Z

2

+50

According personal experiences, find something as generic type first, to avoid circular dependencies. Please check following definitions.

type Layer<K extends string> = Partial<Record<K, ($: Record<K, Function>) => void>>

function layerCompose<K extends string>(...layers: Layer<K>[]): Record<K, Function>
  // ignore how do you implement to match types
  return {} as Record<K, Function>
}

answered Dec 15, 2021 at 8:44

chinesedfan

4491 gold badge4 silver badges10 bronze badges

Collectives™ on Stack Overflow

Typescript: type assist for function argument

2 Answers 2

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related