vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2026-08-11 20:40:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

final polishing

Browse Source
This commit is contained in:
Stepan Burguchev
2017-07-09 18:07:06 +03:00
parent 1b91b09021
commit fb798e5fab
3 changed files with 40 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files
types/seamless-immutable/index.d.ts
Vendored
+27 -19
View File
@@ -1,7 +1,9 @@
// Type definitions for Seamless-immutable 6.1.3
// Project: https://github.com/rtfeldman/seamless-immutable
// Definitions by: alex3165 <https://github.com/alex3165>
// Stepan Burguchev <https://github.com/xsburg>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
// This project is licensed under the MIT license.
// Copyrights are respective of each contributor listed at the beginning of each definition file.
@@ -32,48 +34,54 @@ declare namespace SeamlessImmutable {
deep: boolean;
}
export interface ImmutableObject<T> {
set<K extends keyof T>(property: K, value: T[K]): T & ImmutableObject<T>;
interface IImmutableObject<T> {
set<K extends keyof T>(property: K, value: T[K]): ImmutableObject<T>;
setIn<K extends keyof T>
(propertyPath: [ K ], value: T[K]): T & ImmutableObject<T>;
(propertyPath: [ K ], value: T[K]): ImmutableObject<T>;
setIn<K extends keyof T, L extends keyof T[K]>
(propertyPath: [ K, L ], value: T[K][L]): T & ImmutableObject<T>;
(propertyPath: [ K, L ], value: T[K][L]): ImmutableObject<T>;
setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>
(propertyPath: [ K, L, M ], value: T[K][L][M]): T & ImmutableObject<T>;
(propertyPath: [ K, L, M ], value: T[K][L][M]): ImmutableObject<T>;
setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M]>
(propertyPath: [ K, L, M, N ], value: T[K][L][M][N]): T & ImmutableObject<T>;
(propertyPath: [ K, L, M, N ], value: T[K][L][M][N]): ImmutableObject<T>;
setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>
(propertyPath: [ K, L, M, N, O ], value: T[K][L][M][N][O]): ImmutableObject<T>;
asMutable(): T;
asMutable(opts: AsMutableOptions): T;
merge(part: DeepPartial<T>, config?: MergeConfig): T & ImmutableObject<T>;
merge(part: DeepPartial<T>, config?: MergeConfig): ImmutableObject<T>;
update<K extends keyof T>(property: K, updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
update<K extends keyof T>(property: K, updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
updateIn<K extends keyof T>
(propertyPath: [ K ], updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
(propertyPath: [ K ], updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
updateIn<K extends keyof T, L extends keyof T[K]>
(propertyPath: [ K, L ], updaterFunction: (value: T[K][L], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
(propertyPath: [ K, L ], updaterFunction: (value: T[K][L], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>
(propertyPath: [ K, L, M ], updaterFunction: (value: T[K][L][M], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
(propertyPath: [ K, L, M ], updaterFunction: (value: T[K][L][M], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M]>
(propertyPath: [ K, L, M, N ], updaterFunction: (value: T[K][L][M][N], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
(propertyPath: [ K, L, M, N ], updaterFunction: (value: T[K][L][M][N], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>
(propertyPath: [ K, L, M, N, O ], updaterFunction: (value: T[K][L][M][N][O], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
without<TTarget>(property: keyof T): TTarget & ImmutableObject<TTarget>;
without<TTarget>(...properties: Array<keyof T>): TTarget & ImmutableObject<TTarget>;
without<TTarget>(filter: (value: T[keyof T], key: keyof T) => boolean): TTarget & ImmutableObject<TTarget>;
without<TTarget>(property: keyof T): ImmutableObject<TTarget>;
without<TTarget>(...properties: Array<keyof T>): ImmutableObject<TTarget>;
without<TTarget>(filter: (value: T[keyof T], key: keyof T) => boolean): ImmutableObject<TTarget>;
}
export interface ImmutableArray<T> {
interface IImmutableArray<T> {
asMutable(): Array<T>;
asMutable(opts: AsMutableOptions): Array<T>;
asObject(toKeyValue: (item: T) => [string, any]): ImmutableObject<any>;
flatMap<TTarget>(mapFunction: (item: T) => Array<TTarget>): TTarget[] & ImmutableArray<TTarget>;
flatMap<TTarget>(mapFunction: (item: T) => Array<TTarget>): ImmutableArray<TTarget>;
}
export type ImmutableObject<T> = T & IImmutableObject<T>;
export type ImmutableArray<T> = Array<T> & IImmutableArray<T>;
export type Immutable<T> = ImmutableObject<T> | ImmutableArray<T>;
export function from<T>(obj: Array<T>, options?: Options): Array<T> & ImmutableArray<T>;
export function from<T>(obj: T, options?: Options): T & ImmutableObject<T>;
export function from<T>(obj: Array<T>, options?: Options): ImmutableArray<T>;
export function from<T>(obj: T, options?: Options): ImmutableObject<T>;
export function isImmutable(target: any): boolean;
export function ImmutableError(message: string): Error;
types/seamless-immutable/seamless-immutable-tests.ts
+12 -12
View File
@@ -25,8 +25,8 @@ interface ExtendedUser extends User {
lastName: string;
};
const arrayOfNumbers: number[] & Immutable.ImmutableArray<number> = Immutable.from([0, 2]);
const user: User & Immutable.ImmutableObject<User> = Immutable.from({
const arrayOfNumbers: Immutable.ImmutableArray<number> = Immutable.from([0, 2]);
const user: Immutable.ImmutableObject<User> = Immutable.from({
firstName: 'Angry',
lastName: 'Monkey'
});
@@ -45,14 +45,14 @@ interface ExtendedUser extends User {
// Instance syntax: immutable array
// ---------------------------------------------------------------
{
const array: User[] & Immutable.ImmutableArray<User> = Immutable.from<User>([ { firstName: 'Angry', lastName: 'Monkey' } ]);
const array: Immutable.ImmutableArray<User> = Immutable.from<User>([ { firstName: 'Angry', lastName: 'Monkey' } ]);
// asMutable
const mutableArray1: User[] = array.asMutable();
const mutableArray2: User[] = array.asMutable({ deep: true });
// flatMap
const flatMappedArray: User[] & Immutable.ImmutableArray<User> = array.flatMap((value: User) =>
const flatMappedArray: Immutable.ImmutableArray<User> = array.flatMap((value: User) =>
[value, value]
);
@@ -78,26 +78,26 @@ interface ExtendedUser extends User {
});
// set: property name is strongly checked
const updatedUser: User & Immutable.ImmutableObject<User> = immutableUser.set('firstName', 'Whirlwind');
const updatedUser: Immutable.ImmutableObject<User> = immutableUser.set('firstName', 'Whirlwind');
// setIn: property path is strongly checked for up to 4 arguments
const updatedUser2: ExtendedUser & Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn(['address', 'line1'], 'Small house');
// setIn: property path is strongly checked for up to 5 arguments
const updatedUser2: Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn(['address', 'line1'], 'Small house');
// asMutable
const mutableUser1: User = immutableUser.asMutable();
const mutableUser2: User = immutableUser.asMutable({ deep: true });
// merge: merged part is strongly checked as a deeply partial object
const mergedUser: User & Immutable.ImmutableObject<User> = immutableUserEx.merge({ address: { line1: 'Small house' }, firstName: 'Jack' });
const mergedUser: Immutable.ImmutableObject<User> = immutableUserEx.merge({ address: { line1: 'Small house' }, firstName: 'Jack' });
// update: property name is strongly checked
const updatedUser3: User & Immutable.ImmutableObject<User> = immutableUser.update('firstName', x => x.toLowerCase() + ' Whirlwind');
const updatedUser3: Immutable.ImmutableObject<User> = immutableUser.update('firstName', x => x.toLowerCase() + ' Whirlwind');
// updateIn: property path is strongly checked for up to 4 arguments
const updatedUser4: User & Immutable.ImmutableObject<User> = immutableUserEx.updateIn([ 'address', 'line1' ], x => x.toLowerCase() + ' 43');
// updateIn: property path is strongly checked for up to 5 arguments
const updatedUser4: Immutable.ImmutableObject<User> = immutableUserEx.updateIn([ 'address', 'line1' ], x => x.toLowerCase() + ' 43');
// without: the return type must be specified explicitly or it will be `any`
const simpleUser1: Immutable.ImmutableObject<any> = immutableUserEx.without('address');
const simpleUser2: User & Immutable.ImmutableObject<User> = immutableUserEx.without<User>('address');
const simpleUser2: Immutable.ImmutableObject<User> = immutableUserEx.without<User>('address');
const simpleUser3: Immutable.ImmutableObject<any> = immutableUserEx.without('firstName', 'lastName');
}
types/seamless-immutable/tsconfig.json
+1 -1
View File
@@ -19,4 +19,4 @@
"index.d.ts",
"seamless-immutable-tests.ts"
]
}
}