Hmm.. I'll look into this for you. What you've typed up there seems very reasonable, but sometimes TypeScript requires some convincing.

Are you able to compile the code above? I'm running TS 1.0.3.0. Wondering if TS requires a an actual class to allow extending. The documentation however says extends classType: 8.1.1 http://www.typescriptlang.org/Content/TypeScript%20Language%20Specification.pdf

Ah yes, that example is valid ES6, but not TypeScript.

I haven't tried this, but perhaps this might work:

var _ABRecord = Immutable.Record({ a: 1, b: 2 });
class ABRecord extends _ABRecord {
    getAB() {
        return this.a + this.b;
    }
}

If not, I'll have to look into how to get this working in TypeScript in better form.

Unfortunately not; TypesScript is struggling a lot with this.

Hey @leebyron I see you have added a 4.0 label on that issue.
Any indication on how the records are going to be changed in regards to typescript (also regarding #341)

Hey! I'm not sure yet actually and am open to suggestions.

I'll play with it hopefully around next week and will report

After looking around a bit, I think adding generics to some of the types like Record would solve at least the typing issues in #341 and #564 .

As for inheriting, I'm not entirely sure how that'd work since microsoft/TypeScript#2225 doesn't seem to be worked on. So maybe inheritance for a future version and just make it generic for now?

Let me know if you need to add generics tests for the next version

Is this related to the present inability to type alias, e.g. type MyRecord = Record({foo: ""})? And, consequently, the inability to use a Record as a type in other ways: List<MyRecord>. Assigning to a var and attempting the latter scenario results in a similar error message: Cannot find name 'MyRecord'.

I wonder if it is possible to do this with https://github.com/Microsoft/TypeScript/wiki/What's-new-in-TypeScript#extending-expressions, microsoft/TypeScript#4910 and intersection types (see #341 (comment)). All of the above is available in nightly ts build.

Any ideas?

Works fine like below, with Typescript 1.6.

import Immutable = require("immutable");

const defaultValue = { a: 1, b: 2 }

class ABRecord extends Immutable.Record(defaultValue) {
    getAB() {
        return this.a + this.b;
    }
}

var myRecord = new ABRecord(b:3);
myRecord.getAB();// 4

The subclassing works now (1.6) but the compiler will put off errors about properties not existing if you don't explicitly declare them:

const defaultValue = { a: 1, b: 2 }

class ABRecord extends Immutable.Record(defaultValue) {
    a: number;
    b: number;

    getAB() {
        return this.a + this.b;
    }
}

Back to not working with 1.7. Argh.

I spent a long time trying to the same issue, but at the end of the day, I can't answer the most simple question (maybe someone here can help): Why bother using Immutable.Record in Typescript?

• does a class with no setter method can be considered as immutable?
• should we only use ImmutableJS for collections?

@zhenwenc Such a class would be immutable, but would not have the set functionality, nor default values support. That said, I'm personally inclined towards custom native-TS classes, considering how much hassle it is trying to use Immutable.Record—especially if a solution is liable to break with future versions of TS.

This "workaround" works for me (functionality and code completion wise without errors):

import { Record, Map } from 'immutable';

export interface IModel {
    a?: number;
    b?: number;
}

interface IModelBase extends IModel, Map<string, any> {}

interface ModelBase extends IModel {
    new (values: {[key: string]: any}): IModelBase;
    getAB?: () => number;
}

export type Model = Record.IRecord<ModelBase>;

const ModelBaseRecord: ModelBase = Record({
    a: 1,
    b: 2,
});

class ModelRecord extends ModelBaseRecord {
    public getAB = () => this.a + this.b;
}

export default ModelRecord;

@leonuh @abergs I've created this library that has an interface called TypedRecord that extends from Immutable.Map and changes all return types to the generic provided type.
It has a function called makeTypedFactory that will create Immutable.Record of the type you specify, it's a just a utility but allows you to have typed Record all over the place and is a very very small library.
https://github.com/rangle/typed-immutable-record

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

Latest type definitions are helping out quite a bit more, will be released soon

I created simple typescript lib to create immutable.js record classes with full inheritance support - https://github.com/MrDegriz/immutable-record-class. Maybe it helps to someone.

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: []
    });

Why is this closed. The problem persists.