6

I have a tree structure that looks something like this:

interface TreeData {
  id : number;
  text : string;
  children : TreeData[];
}

I want to wrap this up into an Immutable Map but since I'm using TypeScript, I would like some type safety around using get and set. I found 2 articles online for suggestions on how one might be able to do this, see:

https://github.com/facebook/immutable-js/issues/683 https://blog.mayflower.de/6630-typescript-redux-immutablejs.html

However my problem is that my TreeData contains a list of TreeData children. If I define my ImmutableMap this way:

export interface ImmutableMap<T, K, V> extends Map<K, V> {
  get<I extends keyof T>( key : I & K ) : T[I] & V;
  set<S extends keyof T>( key : S & K, value : T[S] & V ) : Map<K, V>;
}

Then when I try to define the following, I get a typescript error message:

type ImmutableTreeData = ImmutableMap<TreeData, string, string | List<ImmutableTreeData>>;

[TS] Type alias ImmutableTreeData circularly references itself

How can I fix this TypeScript error?

5

2 Answers 2

4
import { Map } from "immutable";

export interface ITypedMap<T> extends Map<string, any> {
  get<K extends keyof T>(name: K): T[K];
}

export function TypedMap<T>(value: T): ITypedMap<T> {
  return Map(value) as ITypedMap<T>;
}

Usage:

const myMap = TypedMap(value);

References:

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

1 Comment

I used this for a small simple case, but it does not work for any function besides .get. There must be a better solution somewhere out there, but I cannot find it.
0

How about a record?

interface ITreeData {
  id: number;
  text: string;
  chilren?: ITreeData;
}

const defaultTreeData: ITreeData = {
  id: 0,
  text: "",
  chilren: undefined
};

class TreeData extends Record(defaultTreeData) {
  public static Init() {
    return new TreeData(defaultTreeData);
  }
}

const treeData = TreeData.Init().set("text", "ok");

const treeData2 = treeData.set("chilren", treeData);

console.log(treeData2);

2 Comments

I didn't want to use records because of the reasons mentioned here: blog.mayflower.de/6630-typescript-redux-immutablejs.html
I see your point. They really weaken the type safety. Note: New typings are now allowing of use recordInstance.user. if you need them.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.