Duplicate of #166 and #341.

I'm currently following advice from #341 (comment) but this involves overwriting the type definitions. I would also prefer a way to do this without requiring defaults to be set—ideally TypeScript should throw an error if you tried to create an object missing a property.

To be honest I spent a few days now and a month ago trying to find a solution that would fit all the points including a record inheritance with custom methods, attributes checking and properties accessing using a dot-notation, but I still haven't found it. This feature mixed with a record generic type definitions you mentioned above could solve most of them microsoft/TypeScript#2225. But there is no progress. @leebyron Could you help us?

One suggestion is to use Immutable’s Records, but in this case I don't want to allow default values.

@OliverJAsh if records work for you setting undefined defaults should be effectively the same as not setting them at all. Am I wrong?

Yes, correct, it's just boilerplate really.

On Tue, 28 Jun 2016 at 19:54 Eugene Mirotin notifications@github.com
wrote:

@OliverJAsh https://github.com/OliverJAsh if records work for you
setting undefined defaults should be effectively the same as not setting
them at all. Am I wrong?

—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
#683 (comment),
or mute the thread
https://github.com/notifications/unsubscribe/AA4QCbtrhyPnmGe85DfJFGg4k-nqLyPoks5qQW3IgaJpZM4GYB74
.

I found a class to get prop name as string array, then implemented a SetValue Method this has some rough edges.

export class NavigableObject<T>{
    constructor(private obj: T, private path: string[] = []) { }

    To<R>(p: (x: T) => R): NavigableObject<R> {

        let propName = this.getPropName(p)

        if (propName) {
            return new NavigableObject<R>(
                p(this.obj),
                this.path.concat(propName)
            );
        } else {
            return new NavigableObject<R>(
                p(this.obj),
                this.path
            );
        }
    }

    getPath() {
        return this.path;
    }


    private static propertyRegEx = /\.([^\.;]+);?\s*\}$/;

    private getPropName(propertyFunction: Function) {
        let value = NavigableObject.propertyRegEx.exec(propertyFunction.toString())
        if (value)
            return value[1];
    }
}

function NavigatableRecordFactory<X>(defaultValues: X, name?: string) {
    abstract class NavigatableRecord<P extends NavigatableRecord<P>> extends Record(defaultValues, name) {
        SetValue<T>(fn: (x: NavigableObject<P>) => NavigableObject<T>, value: T) {
            return this.setIn(fn(new NavigableObject<any>(this)).getPath(), value)
        }
    }
    return NavigatableRecord;
}

interface IUSER {
    Name: string;
    Age: number;
}

export class USER extends NavigatableRecordFactory<IUSER>({
    Name: "Simy the bothless",
    Age: 27,
})<USER> implements IUSER {
    Name: string;
    Age: number;
}

and then use it like

state.Name // works

state.SetValue(t => t.To(q => q.Name), "test string") // typecheks
state.SetValue(t => t.To(q => q.Name), 123) // error

it also works with nested properties

somenestedImmutable.SetValue(t =>t.To(q => q.Date).To(q => q.Time), 213213123)

but cant get it work without needing to implement method in child class ,
little help would be nice if it is possible :)

Typescript v.2.1.0-dev20160805

Hi Guys,
its 2017, so can we Type a Map now with immutablejs and TypeScript? Specifically enforce the keys.
Posted here: http://stackoverflow.com/questions/41798302/how-do-you-type-an-immutablejs-map-keys
but no one seems to know, odd :/

regards

Sean

Checkout the Ultimate Angular 2 Boorstrap App: @ http://ng2.javascriptninja.io
Source@ https://github.com/born2net/ng2Boilerplate

Fixed in master, will be released soon

looking fwd to it...
what release will it land on?

was this released already?

fyi I tried with latest release immutable beta rc and no luck

interface ITimelineState {
    zoom: number;
    duration: number;
    channels: Array<IChannels>;
    outputs: Array<IOutputs>;
    items: Array<IItem>;
}

let state: Map<any, ITimelineState> = Map({ // <<<< ERROR
        zoom: 1,
        duration: 500,
        channels: [],
        outputs: [],
        items: []
    });

@leebyron Can we see any example of usage?

ya same... really need an example please

Is this released? An example would be great!

any news on this?

@leebyron can you please post the commits related to fix?

Hello from july 6

Hello from July 26th

@leebyron any news on this? would love to be able to Type Maps

@leebyron Hello from October 2017! an example would be much appreciated :)

same!

You may want to look to the TypeScript documentation for examples of how to use TypeScript.

Map is defined in terms of the type of the keys it contains and the type of the values it contains, respectively. It appears as: Map<KeyType, ValueType> in TypeScript.

For example, if you wanted a Map with string keys and number values, you'd write Map<string, number>. For the example above Map<any, ITimelineState>, this declares a Map that will accept any value as a key, and instances of ITimelineState as values.

For cases where the type of value at each key will be different depending on the key, then Map is likely the wrong choice. Maps are intended for homogeneous collections. For heterogeneous collections with a fixed known set of keys, Record is a better fit.

You can see examples of using Record in the Immutable.js documentation here: http://facebook.github.io/immutable-js/docs/#/Record

An example usage for those wondering (following this post), where you want to type check every property accesed via get:

interface IProduct {
  price: number;
  description: string;
}

What you do is first to declare a typing interface for your Product as it were a Plan Old JavaScript object. Then you proceed to "wrap" it extending Immutable.Map:

interface IImmutableProduct extends Immutable.Map<string, any> {
   toJS(): IProduct;
   get<K extends keyof IProduct>(key: K): IProduct[K];
}

Thus you'll have type checking over the getter functions of Product, in this case .get('price') and .get('description').

That's great, can't wait to test it

Hi there, I make some attempt and get a solution with out any like this:

interface ImMap<T, K, V> extends Map<K, V> {
  toJS(): T;
  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>;
}
//test
interface StringMap {
  [propName: string]: string;
}
type ImStringMap = ImMap<D.StringMap, string, string>;

interface Attach {
  val: string;
  type: number;
  sh1?: string;
  keyName?: string;
}
type ImAttach = ImMap<D.Attach, string, string | number>;

It works well for me.

@odiseo42 @Saul-Mirone thanks for the examples!
Any proposals for getIn method?

seems to work:

interface IMAPTScannerTabSelection extends Map<string, any> {
    toJS(): IScannerTabSelection;
    get<K extends keyof IScannerTabSelection>(key: K): IScannerTabSelection[K];
}



const scannerTabSelection = {
    mainTab: {
        value: EnumScannerMainTab.MAINTAB_BLOCKS
    },
    switchTab: {
        value: EnumScannerSwitchTab.SWITCH_BROWSE_BLOCKS22
    }
};

var a:IMAPTScannerTabSelection = Map(scannerTabSelection);
var b = a.get("switchTab")
console.log(b);

and got auto completion and error detection in Angular 5 / TS

Can anyone help answer this question: https://stackoverflow.com/questions/52824312/how-to-use-immutablejs-map-with-typescript

I can't figure out how to define my ImmutableMap in TypeScript that contains a List of (child) ImmutableMaps.

@odiseo42 What if I need to access the full object. Any workaround for that?

@kushalmahajan this project more dead than alive, try immer instead

@JustFly1984 Thanks for the suggestion but I cannot just try new package. Already deep into it.

Well, I was deep in immutable.js with 5 projects,until we had to refactor all the projects to typescript, it happened that there is no support :/ we had to refactor anyway, and used immer as 100% typescript support. Also this library is unmaintained for way too long and there is some bugs which killing all the benefits. For example if you have a list of strings more than 32 items, it will iterate without an order :/

Guys in 2020 and with ES6 you don't need immutable, IMHO :)

@DonikaV
We need some kind of data structures with persistence properties, cos immutability is not enough for performance optimized algorithms.

Immutability by itself can be provided with Object.freeze() recursively or shallow. Or simply use immer library. But persistence by itself provides huge performance boost