Factory Pattern Utilizing Enum for Field Population

Question

Factory Pattern Utilizing Enum for Field Population

Struggling to find a solution for setting default values for instances created by the factory method createLetterMap...

I don't think the problem lies in 'How to loop over enums' because it seems impossible due to types not being available at run-time. However, I might be missing something regarding string enums?


enum Letter{
    A = "A",
    B = "B",
    E = "E",
    I = "I",

}
type Vowl = Letter.A | Letter.E | Letter.I

class LMAP{
    test(){}
}
function createLetterMap<T extends Letter>(){
    let lmapExtended = new LMAP() as LMAP & {
        [key in T]?:string
    };

    // ?? create default values for keys somehow ??

    return lmapExtended;
}

let vowlMap = createLetterMap<Vowl>()

vowlMap[Letter.E] = "Eat" // OK
// vowlMap[Letter.B] = "Bat" // Error! Good!

let defaultVal = vowlMap[Letter.A]; // undefined. Would like it to be populated.

My goal is to use unions of string enums to generate objects with keys that can be used similar to this scenario:

fn(v:Vowl){

  ...

  letterMap[v].someVowlReleatedWork()

  ...

}

While using Maps is a working alternative, I feel there could be a cleaner way if types are specified correctly...

The current workaround involves creating an array of enums included in the union type and utilizing both the union and the array in the factory method, which doesn't seem ideal:

...

let Vowls = [Letter.A,... ]
createLetterMap<Vowl>(Vowls)

typescript enums typescript-generics

Answer 1

Answer №1

Using type definitions as values is not possible because they are removed at runtime - for(let key of keyof Vowl would not function.

To work around this limitation, you could create the map as a class or utilize a custom transformer like ts-transformer-keys to extract keys at runtime.


enum Letter {
  A = "A",
  B = "B",
  E = "E",
  I = "I",

}
type Vowl = Letter.A | Letter.E | Letter.I

interface IMapper<T> { operation(value: T): void }

class VowlMapper implements IMapper<Vowl> {
  operation(vowel: Vowl) {
    console.log("VowlMapper: " + vowel);
  }
}

class LetterMap<T extends Letter> {

  private map: IMapper<T> & { [key in T]?: string };

  constructor(map: IMapper<T>) {
    this.map = map;
  }

  get(letter: T) {
    return this.map[letter] ?? letter;
  }

  set(letter: T, value: any) {
    this.map[letter] = value;
  }

  operation(value: T) {
    return this.map.operation(value);
  }

}

let vowlMap = new LetterMap(new VowlMapper())

vowlMap.set(Letter.E, "Eat");
// vowlMap.set(Letter.B, "Bat"); // Error! Good!

console.log(vowlMap.get(Letter.A))  // A
//console.log(vowlMap.get(Letter.B))  // error
console.log(vowlMap.get(Letter.E))  // Eat

vowlMap.operation(Letter.A); // VowlMapper: A

Test out the playground example.

Answer 2

Using type definitions as values is not possible because they are removed at runtime - for(let key of keyof Vowl would not function.

To work around this limitation, you could create the map as a class or utilize a custom transformer like ts-transformer-keys to extract keys at runtime.


enum Letter {
  A = "A",
  B = "B",
  E = "E",
  I = "I",

}
type Vowl = Letter.A | Letter.E | Letter.I

interface IMapper<T> { operation(value: T): void }

class VowlMapper implements IMapper<Vowl> {
  operation(vowel: Vowl) {
    console.log("VowlMapper: " + vowel);
  }
}

class LetterMap<T extends Letter> {

  private map: IMapper<T> & { [key in T]?: string };

  constructor(map: IMapper<T>) {
    this.map = map;
  }

  get(letter: T) {
    return this.map[letter] ?? letter;
  }

  set(letter: T, value: any) {
    this.map[letter] = value;
  }

  operation(value: T) {
    return this.map.operation(value);
  }

}

let vowlMap = new LetterMap(new VowlMapper())

vowlMap.set(Letter.E, "Eat");
// vowlMap.set(Letter.B, "Bat"); // Error! Good!

console.log(vowlMap.get(Letter.A))  // A
//console.log(vowlMap.get(Letter.B))  // error
console.log(vowlMap.get(Letter.E))  // Eat

vowlMap.operation(Letter.A); // VowlMapper: A

Test out the playground example.

Answer 3

Answer №2

An interesting method I've discovered (especially in terms of utilizing the output) involves using a const array of enums. The process is somewhat complex; there is a risk of accidentally overwriting LMAP fields with the input enum collection...

When setting default values, it appears necessary to cast to any, although the reason behind this action is unclear. Given that the input array must consist of Letter enums, the casting doesn't concern me much, but it does seem a bit peculiar...

enum Letter{
    A = "A",
    B = "B",
    E = "E",
    I = "I"    
}

// Using a const array for subsets allows for an iterable structure and a basis for type derivation
const Vowls = <const> [
    Letter.A,
    Letter.E,
    Letter.I
];

// Define the base class to 'extend'
class LMAP{};
// Function that accepts a const array of the original enum type for type information and iteration 
function createLMAP<T extends Readonly<Array<Letter>>,T2>(letterArray:T,defaultVal:T2){    
    let n = new LMAP() as LMAP & {[key in typeof letterArray[number]]:T2};
    letterArray.forEach(key=>{                
        n[key as T[number]] = defaultVal as any; // Unsure about the need to cast to any here...
    });
    return n;
}

// Voila!
let vm = createLMAP(Vowls,0);

// Testing phase
Vowls.forEach(v=>{
    vm[v] += 1;
})
vm[Letter.A] = 1;
vm[Letter.B] = 1; // Error caused by lack of implicit any

// Derive a union type for future use...
type Vowl = typeof Vowls[number]; 
// Example usage:
function work(v:Vowl){
    vm[v] = 1;
}
work(Letter.A)
work(Letter.B) // Error!

While I'm not confirming this as the definitive answer, it's the path I personally prefer.

Answer 4

An interesting method I've discovered (especially in terms of utilizing the output) involves using a const array of enums. The process is somewhat complex; there is a risk of accidentally overwriting LMAP fields with the input enum collection...

When setting default values, it appears necessary to cast to any, although the reason behind this action is unclear. Given that the input array must consist of Letter enums, the casting doesn't concern me much, but it does seem a bit peculiar...

enum Letter{
    A = "A",
    B = "B",
    E = "E",
    I = "I"    
}

// Using a const array for subsets allows for an iterable structure and a basis for type derivation
const Vowls = <const> [
    Letter.A,
    Letter.E,
    Letter.I
];

// Define the base class to 'extend'
class LMAP{};
// Function that accepts a const array of the original enum type for type information and iteration 
function createLMAP<T extends Readonly<Array<Letter>>,T2>(letterArray:T,defaultVal:T2){    
    let n = new LMAP() as LMAP & {[key in typeof letterArray[number]]:T2};
    letterArray.forEach(key=>{                
        n[key as T[number]] = defaultVal as any; // Unsure about the need to cast to any here...
    });
    return n;
}

// Voila!
let vm = createLMAP(Vowls,0);

// Testing phase
Vowls.forEach(v=>{
    vm[v] += 1;
})
vm[Letter.A] = 1;
vm[Letter.B] = 1; // Error caused by lack of implicit any

// Derive a union type for future use...
type Vowl = typeof Vowls[number]; 
// Example usage:
function work(v:Vowl){
    vm[v] = 1;
}
work(Letter.A)
work(Letter.B) // Error!

While I'm not confirming this as the definitive answer, it's the path I personally prefer.

Factory Pattern Utilizing Enum for Field Population

Answer №1

Answer №2

Similar questions

Combine two elements in an array

typescript function intersection types

Using Angular 6 to Format Dates

Seeking a quick conversion method for transforming x or x[] into x[] in a single line of code

tsc is not recognizing the configurations in my tsconfig.json file

What sets apart the two methods of defining an event in a React component?

Solving issues with malfunctioning Angular Materials

Typescript headaches: Conflicting property types with restrictions

Issue with accessing custom method in subclass in Typescript

Create a chronological timeline based on data from a JSON object

Troubles encountered when trying to execute mocha within Firebase functions

What is the best way to send two separate properties to the selector function?

Express throwing module errors

Generic type array does not display property

Unable to locate the next/google/font module in my Typescript project

Is there a method in TypeScript to make an enum more dynamic by parameterizing it?

"Prisma vs. Supabase: A Comparison of Image Uploading

Comparison between a Typescript optional field and a field that has the potential to be undefined

Creating synchronous behavior using promises in Javascript

Find the appropriate return type for a TypeScript function based on its argument