type-fest 2.12.2 → 2.14.0

package/source/set-required.d.ts

@@ -1,5 +1,5 @@
-import {Except} from './except';
-import {Simplify} from './simplify';
+import type {Except} from './except';
+import type {Simplify} from './simplify';
 
 /**
 Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
@@ -8,7 +8,7 @@ Use-case: You want to define a single model where the only thing that changes is
 
 @example
 ```
-import {SetRequired} from 'type-fest';
+import type {SetRequired} from 'type-fest';
 
 type Foo = {
 	a?: number;

package/source/set-return-type.d.ts

@@ -9,7 +9,7 @@ Use-case: You want to define a wrapped function that returns something different
 
 @example
 ```
-import {SetReturnType} from 'type-fest';
+import type {SetReturnType} from 'type-fest';
 
 type MyFunctionThatCanThrow = (foo: SomeType, bar: unknown) => SomeOtherType;
 

package/source/simplify.d.ts

@@ -3,7 +3,7 @@ Useful to flatten the type output to improve type hints shown in editors. And al
 
 @example
 ```
-import {Simplify} from 'type-fest';
+import type {Simplify} from 'type-fest';
 
 type PositionProps = {
 	top: number;
@@ -25,7 +25,7 @@ If the type definition must be an interface (perhaps it was defined in a third-p
 
 @example
 ```
-import {Simplify} from 'type-fest';
+import type {Simplify} from 'type-fest';
 
 interface SomeInterface {
 	foo: number;

package/source/snake-case.d.ts

@@ -1,4 +1,4 @@
-import {DelimiterCase} from './delimiter-case';
+import type {DelimiterCase} from './delimiter-case';
 
 /**
 Convert a string literal to snake-case.
@@ -7,7 +7,7 @@ This can be useful when, for example, converting a camel-cased object property t
 
 @example
 ```
-import {SnakeCase} from 'type-fest';
+import type {SnakeCase} from 'type-fest';
 
 // Simple
 

package/source/snake-cased-properties-deep.d.ts

@@ -1,4 +1,4 @@
-import {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
+import type {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
 
 /**
 Convert object properties to snake case recursively.
@@ -10,6 +10,8 @@ This can be useful when, for example, converting some API types from a different
 
 @example
 ```
+import type {SnakeCasedPropertiesDeep} from 'type-fest';
+
 interface User {
 	userId: number;
 	userName: string;

package/source/snake-cased-properties.d.ts

@@ -1,4 +1,4 @@
-import {DelimiterCasedProperties} from './delimiter-cased-properties';
+import type {DelimiterCasedProperties} from './delimiter-cased-properties';
 
 /**
 Convert object properties to snake case but not recursively.
@@ -10,6 +10,8 @@ This can be useful when, for example, converting some API types from a different
 
 @example
 ```
+import type {SnakeCasedProperties} from 'type-fest';
+
 interface User {
 	userId: number;
 	userName: string;

package/source/split.d.ts

@@ -5,7 +5,7 @@ Use-case: Defining the return type of a method like `String.prototype.split`.
 
 @example
 ```
-import {Split} from 'type-fest';
+import type {Split} from 'type-fest';
 
 declare function split<S extends string, D extends string>(string: S, separator: D): Split<S, D>;
 

package/source/string-key-of.d.ts

@@ -9,7 +9,7 @@ Use-cases:
 
 @example
 ```
-import {StringKeyOf} from 'type-fest';
+import type {StringKeyOf} from 'type-fest';
 
 type Foo = {
 	1: number,

package/source/stringified.d.ts

@@ -5,7 +5,7 @@ Use-case: Changing interface values to strings in order to use them in a form mo
 
 @example
 ```
-import {Stringified} from 'type-fest';
+import type {Stringified} from 'type-fest';
 
 type Car {
 	model: string;

package/source/trim.d.ts

@@ -13,7 +13,7 @@ Remove leading and trailing spaces from a string.
 
 @example
 ```
-import {Trim} from 'type-fest';
+import type {Trim} from 'type-fest';
 
 Trim<' foo '>
 //=> 'foo'

package/source/union-to-intersection.d.ts

@@ -5,7 +5,7 @@ Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/21
 
 @example
 ```
-import {UnionToIntersection} from 'type-fest';
+import type {UnionToIntersection} from 'type-fest';
 
 type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
 
@@ -17,7 +17,7 @@ A more applicable example which could make its way into your library code follow
 
 @example
 ```
-import {UnionToIntersection} from 'type-fest';
+import type {UnionToIntersection} from 'type-fest';
 
 class CommandOne {
 	commands: {

package/source/value-of.d.ts

@@ -13,7 +13,7 @@ Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438)
 }
 
 // main.ts
-import {ValueOf} from 'type-fest';
+import type {ValueOf} from 'type-fest';
 import data = require('./data.json');
 
 export function getData(name: string): ValueOf<typeof data> {

package/source/writable.d.ts

@@ -0,0 +1,40 @@
+import type {Except} from './except';
+import type {Simplify} from './simplify';
+
+/**
+Create a type that strips `readonly` from all or some of an object's keys. Inverse of `Readonly<T>`.
+
+This can be used to [store and mutate options within a class](https://github.com/sindresorhus/pageres/blob/4a5d05fca19a5fbd2f53842cbf3eb7b1b63bddd2/source/index.ts#L72), [edit `readonly` objects within tests](https://stackoverflow.com/questions/50703834), [construct a `readonly` object within a function](https://github.com/Microsoft/TypeScript/issues/24509), or to define a single model where the only thing that changes is whether or not some of the keys are writable.
+
+@example
+```
+import type {Writable} from 'type-fest';
+
+type Foo = {
+	readonly a: number;
+	readonly b: readonly string[]; // To show that only the mutability status of the properties, not their values, are affected.
+	readonly c: boolean;
+};
+
+const writableFoo: Writable<Foo> = {a: 1, b: ['2'], c: true};
+writableFoo.a = 3;
+writableFoo.b[0] = 'new value'; // Will still fail as the value of property "b" is still a readonly type.
+writableFoo.b = ['something']; // Will work as the "b" property itself is no longer readonly.
+
+type SomeWritable = Writable<Foo, 'b' | 'c'>;
+// type SomeWritable = {
+// 	readonly a: number;
+// 	b: readonly string[]; // It's now writable. The type of the property remains unaffected.
+// 	c: boolean; // It's now writable.
+// }
+```
+
+@category Object
+*/
+export type Writable<BaseType, Keys extends keyof BaseType = keyof BaseType> =
+	Simplify<
+		// Pick just the keys that are not writable from the base type.
+		Except<BaseType, Keys> &
+		// Pick the keys that should be writable from the base type and make them writable by removing the `readonly` modifier from the key.
+		{-readonly [KeyType in keyof Pick<BaseType, Keys>]: Pick<BaseType, Keys>[KeyType]}
+	>;

package/license

@@ -1 +0,0 @@
-SPDX-License-Identifier: (MIT OR CC0-1.0)