In TypeScript, is it possible to remove the readonly modifier from a type?
For example:
type Writeable<T> = { [P in keyof T]: T[P] };
Usage:
interface Foo {
readonly bar: boolean;
}
let baz: Writeable<Foo>;
baz.bar = true;
Is it possible to add a modifier to the type to make all the properties writeable?
Since typescript 2.8 there's a new way to do it:
type Writeable<T> = { -readonly [P in keyof T]: T[P] };
If you need your type to be writeable recursively, then:
type DeepWriteable<T> = { -readonly [P in keyof T]: DeepWriteable<T[P]> };
These type definitions are called mapped types
There's a way:
type Writeable<T extends { [x: string]: any }, K extends string> = {
[P in K]: T[P];
}
But you can go the opposite way and it will make things much easier:
interface Foo {
bar: boolean;
}
type ReadonlyFoo = Readonly<Foo>;
let baz: Foo;
baz.bar = true; // fine
(baz as ReadonlyFoo).bar = true; // error
type Writeable<T> = { -readonly [P in keyof T]: T[P] }; works great even for classes used as T because when using the class keyword in TypeScript, you are actually creating TypeScript interface containing all the instance methods and properties of the class! (fyi the second thing created with the TypeScript class keyword is a JavaScript variable with a different (anonymous) constructor function type.)
DeepWritable from ts-essentials has worked well though and is basically a more complete version of the one presented in this answer (handles maps, functions, sets, promises etc).
type Writeable<T> = { -readonly [P in keyof T]: T[P] }; works flawlessly for readonly tuple types (usually created from const assertions on array literals) even though it looks like it's geared towards objects only.
DeepWriteable saved my day, thank you very much!To add to accepted answer, if you just wanna remove one or a small number of readonly props from a type you can do this (playground):
interface Foo {
readonly bar: boolean;
}
type WriteableFoo = Foo & { bar: Foo['bar'] };
const baz: Foo = { bar: true };
// baz.bar = true; // Cannot assign to 'bar' because it is a read-only property.(2540)
(baz as WriteableFoo).bar = false;
Works in v4 and 5, but strangely, doesn't work in v3 (and presumably earlier).
Sorry to point out something obvious (it's perhaps not what you're looking for), but if you know what the original type is going to be you can just cast it back to the original type. This doesn't work if you're looking for a generic way to possibly remove the readonly-ness of a possibly readonly type or do so recursively...
type Foo = { x: number }
const y: Readonly<Foo> = {x: 3};
// y.x = 4 // error
(y as Foo).x = 4 // okay
/// JSDOC style
// @ts-check
/**
* @typedef {Object} Foo
* @property {number} x
*/
/** @type {Readonly<Foo>} */
const y = { x: 3 };
// y.x = 4 // error
/** @type {Foo} */(y).x = 3 // okay
Writable<T> approach comes in handy, in my experience.