Generate a complex string literal combination when the intermediary types or names are uncertain

Question

Generate a complex string literal combination when the intermediary types or names are uncertain

My goal is to consolidate a group of nested string literals into one union.

The structure I am working with typically looks like this:

typechainTypes.factories.contracts
|
|----->Lock__factory (extends ContractFactory)
|           |-----> contractName: string
|----->****** (this is a `export * as foo from bar`)
            |-----> ****** (want to extract only if it extends ContractFactory; Extract<Foo, ContractFactory> type didn't work)
                      |-----> contractName: stringcontractName: string

This is what I envision in pseudocode:

type ContractFactories = typechainTypes.factories.contracts.**.* extends ContractFactory ? ___ : never;
type ContractNames = ContractFactories['contractName'];

In simpler terms:

type LookForFactory<T> = T.flatMap(foo => {
    if (foo extends ContractFactory)
        return foo;
    else if (foo === undefined || foo === null || foo is SomePrimitive)
        return never;
    else
        return LookForFactory<foo>;
}
type ContractNames = LookForFactory<typechainTypes.factories.contracts>;

The desired outcome should be a union consisting of these options:

typechainTypes.factories.contracts.Lock__factory.contractName
typechainTypes.factories.contracts.SomethingA.this_is_a__factory.contractName
typechainTypes.factories.contracts.SomethingB.SomethingC.this_is_a__factory.contractName
typechainTypes.factories.contracts.*.*.*.*.this_is_a__factory.contractName

If achieving an unknown depth is proving to be too complex, I would settle for a union of:

typechainTypes.factories.contracts.Lock__factory.contractName
typechainTypes.factories.contracts.UnknownNameA.UnknownNameB__factory.contractName

Initially, I attempted this using

Parameters<ethers.getContractFactory>[0]

, but the presence of any in the final overload led to any[], which was not helpful. Finding a way to exclude the any[] override remains a challenge.

Thank you!

typescript hardhat typechain

Answer 1

Answer №1

It seems like what you're looking for is:

type FindFactory<T> = {
  [K in keyof T & string]:
    T[K] extends ContractFactory
      ? K
      : `${K}.${FindFactory<T[K]>}`
}[keyof T & string]

This ingenious code snippet defines a recursive conditional type.

Firstly, it iterates over the keys of type T as K, considering only those that are strings.
If the value at key K in type T is a ContractFactory, it returns that key.
If the value at key K in type T is anything else, it merges the parent key K with all matches found in the nested object: ${K}.${FindFactory<T[K]>}.
Finally, by using [keyof T & string] indexing, we obtain the value types of the newly created object as a union.

Let's put this into action with an example:

type ContractFactory = {
  contractName: string
}

type Typechain = { 
 // Nested objects representing contracts and factories
}

type FactoryNames = FindFactory<Typechain>;
/*
List of factory names extracted from the provided input.
*/

Explore Playground

Answer 2

It seems like what you're looking for is:

type FindFactory<T> = {
  [K in keyof T & string]:
    T[K] extends ContractFactory
      ? K
      : `${K}.${FindFactory<T[K]>}`
}[keyof T & string]

This ingenious code snippet defines a recursive conditional type.

Firstly, it iterates over the keys of type T as K, considering only those that are strings.
If the value at key K in type T is a ContractFactory, it returns that key.
If the value at key K in type T is anything else, it merges the parent key K with all matches found in the nested object: ${K}.${FindFactory<T[K]>}.
Finally, by using [keyof T & string] indexing, we obtain the value types of the newly created object as a union.

Let's put this into action with an example:

type ContractFactory = {
  contractName: string
}

type Typechain = { 
 // Nested objects representing contracts and factories
}

type FactoryNames = FindFactory<Typechain>;
/*
List of factory names extracted from the provided input.
*/

Explore Playground

Generate a complex string literal combination when the intermediary types or names are uncertain

Answer №1

Similar questions

Utilizing Angular's Dependency Injection to Provide Services to External Libraries

Vitek - Uncaught ReferenceError: Document Is Not Defined

The information in the map cannot be inferred by Typescript based on the generic key type

What causes the appearance of the "?" symbol at the beginning of the URL and triggers a reboot of the app when moving through the absolute path?

Tips for transferring information from a Sidemenu to a different page during navigation

Setting a maximum limit for selections in MUI Autocomplete

Creating objects in Angular 2 through HTTP GET calls

NextJS is currently unable to identify and interpret TypeScript files

Angular: Deciding Between Utilizing Boolean @Input and Attribute @Directive - What's the Best Approach?

The ins and outs of Angular's type checking mechanisms

MobX React not causing re-render when props change

Is it possible to convert a string using object-to-object syntax?

What could be causing my component to not refresh when used as a child?

ERROR: Unhandled promise rejection: Route cannot be found. URL Segment: 'details'

Dynamic row generation with dropdown menu and data binding

Error message encountered: Missing property status in TypeScript code

Create a new TypeScript object without any initial properties, then proceed to define its attributes

typescript decorator implemented on a class that is nested within another class

How can I verify the "Type" of user input in a custom React TypeScript hook?

Exploring TypeScript's Conditional Types