@types/seamless-immutable - npm Package Compare versions

Comparing version 7.1.16 to 7.1.17

seamless-immutable/index.d.ts

@@ -23,3 +23,3 @@ // Type definitions for Seamless-immutable 7.1
         deep?: boolean | undefined;
-        mode?: 'replace' | 'merge' | undefined;
+        mode?: "replace" | "merge" | undefined;
         merger?(a: any, b: any, config: any): any;
@@ -44,22 +44,57 @@ }
 
-        setIn<K extends keyof T>(propertyPath: [ K ], value: T[K]): Immutable<T>;
-        setIn<K extends keyof T, L extends keyof T[K]>(propertyPath: [ K, L ], value: T[K][L]): Immutable<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]): Immutable<T>;
+        setIn<K extends keyof T>(propertyPath: [K], value: T[K]): Immutable<T>;
+        setIn<K extends keyof T, L extends keyof T[K]>(propertyPath: [K, L], value: T[K][L]): Immutable<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],
+        ): Immutable<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]): Immutable<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]): Immutable<T>;
+            propertyPath: [K, L, M, N],
+            value: T[K][L][M][N],
+        ): Immutable<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],
+        ): Immutable<T>;
         setIn<TValue>(propertyPath: string[], value: TValue): Immutable<T>;
 
-        getIn<K extends keyof T>(propertyPath: [ K ]): Immutable<T[K]>;
-        getIn<K extends keyof T>(propertyPath: [ K ], defaultValue: T[K]): Immutable<T[K]>;
-        getIn<K extends keyof T, L extends keyof T[K]>(propertyPath: [ K, L ]): Immutable<T[K][L]>;
-        getIn<K extends keyof T, L extends keyof T[K]>(propertyPath: [ K, L ], defaultValue: T[K][L]): Immutable<T[K][L]>;
-        getIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>(propertyPath: [ K, L, M ]): Immutable<T[K][L][M]>;
-        getIn<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 ]): Immutable<T[K][L][M][N]>;
-        getIn<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 ], defaultValue: T[K][L][M][N]): Immutable<T[K][L][M][N]>;
-        getIn<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 ]): Immutable<T[K][L][M][N][O]>;
-        getIn<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 ], defaultValue: T[K][L][M][N][O]): Immutable<T[K][L][M][N][O]>;
+        getIn<K extends keyof T>(propertyPath: [K]): Immutable<T[K]>;
+        getIn<K extends keyof T>(propertyPath: [K], defaultValue: T[K]): Immutable<T[K]>;
+        getIn<K extends keyof T, L extends keyof T[K]>(propertyPath: [K, L]): Immutable<T[K][L]>;
+        getIn<K extends keyof T, L extends keyof T[K]>(propertyPath: [K, L], defaultValue: T[K][L]): Immutable<T[K][L]>;
+        getIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>(
+            propertyPath: [K, L, M],
+        ): Immutable<T[K][L][M]>;
+        getIn<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],
+        ): Immutable<T[K][L][M][N]>;
+        getIn<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],
+            defaultValue: T[K][L][M][N],
+        ): Immutable<T[K][L][M][N]>;
+        getIn<
+            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],
+        ): Immutable<T[K][L][M][N][O]>;
+        getIn<
+            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],
+            defaultValue: T[K][L][M][N][O],
+        ): Immutable<T[K][L][M][N][O]>;
         getIn(propertyPath: string[]): Immutable<any>;
@@ -74,16 +109,49 @@ getIn<TValue>(propertyPath: string[], defaultValue: TValue): Immutable<TValue>;
 
-        update<K extends keyof T>(property: K, updaterFunction: (value: Immutable<T[K]>, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
-        update<TValue>(property: string, updaterFunction: (value: Immutable<TValue>, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
+        update<K extends keyof T>(
+            property: K,
+            updaterFunction: (value: Immutable<T[K]>, ...additionalParameters: any[]) => any,
+            ...additionalArguments: any[]
+        ): Immutable<T>;
+        update<TValue>(
+            property: string,
+            updaterFunction: (value: Immutable<TValue>, ...additionalParameters: any[]) => any,
+            ...additionalArguments: any[]
+        ): Immutable<T>;
 
         updateIn<K extends keyof T>(
-            propertyPath: [ K ], updaterFunction: (value: Immutable<T[K]>, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
+            propertyPath: [K],
+            updaterFunction: (value: Immutable<T[K]>, ...additionalParameters: any[]) => any,
+            ...additionalArguments: any[]
+        ): Immutable<T>;
         updateIn<K extends keyof T, L extends keyof T[K]>(
-            propertyPath: [ K, L ], updaterFunction: (value: Immutable<T[K][L]>, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
+            propertyPath: [K, L],
+            updaterFunction: (value: Immutable<T[K][L]>, ...additionalParameters: any[]) => any,
+            ...additionalArguments: any[]
+        ): Immutable<T>;
         updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>(
-            propertyPath: [ K, L, M ], updaterFunction: (value: Immutable<T[K][L][M]>, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
+            propertyPath: [K, L, M],
+            updaterFunction: (value: Immutable<T[K][L][M]>, ...additionalParameters: any[]) => any,
+            ...additionalArguments: any[]
+        ): Immutable<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: Immutable<T[K][L][M][N]>, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<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: Immutable<T[K][L][M][N][O]>, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
-        updateIn<TValue = any>(propertyPath: string[], updaterFunction: (value: TValue, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): Immutable<T>;
+            propertyPath: [K, L, M, N],
+            updaterFunction: (value: Immutable<T[K][L][M][N]>, ...additionalParameters: any[]) => any,
+            ...additionalArguments: any[]
+        ): Immutable<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: Immutable<T[K][L][M][N][O]>, ...additionalParameters: any[]) => any,
+            ...additionalArguments: any[]
+        ): Immutable<T>;
+        updateIn<TValue = any>(
+            propertyPath: string[],
+            updaterFunction: (value: TValue, ...additionalParameters: any[]) => any,
+            ...additionalArguments: any[]
+        ): Immutable<T>;
 
@@ -99,3 +167,7 @@ without<K extends keyof T>(property: K): Immutable<T>;
     /** An ImmutableArray provides read-only access to the array elements, and provides functions (such as `map()`) that return immutable data structures. */
-    type ImmutableArray<T> = Readonly<ImmutableArray.Remaining<T>> & ImmutableArray.Additions<T> & ImmutableArray.Overrides<T> & ImmutableArray.ReadOnlyIndexer<T>;
+    type ImmutableArray<T> =
+        & Readonly<ImmutableArray.Remaining<T>>
+        & ImmutableArray.Additions<T>
+        & ImmutableArray.Overrides<T>
+        & ImmutableArray.ReadOnlyIndexer<T>;
     namespace ImmutableArray {
@@ -108,3 +180,5 @@ /** New methods added by seamless-immutable. */
 
-            asObject<U extends object = {}, K extends keyof U = keyof U>(toKeyValue: (item: T) => [K, U[K]]): Immutable<U>;
+            asObject<U extends object = {}, K extends keyof U = keyof U>(
+                toKeyValue: (item: T) => [K, U[K]],
+            ): Immutable<U>;
             flatMap<TTarget>(mapFunction: (item: T) => TTarget): Immutable<TTarget extends any[] ? TTarget : TTarget[]>;
@@ -115,11 +189,46 @@ }
         interface Overrides<T> {
-            forEach(callbackfn: (value: Immutable<T>, index: number, array: Immutable<T[]>) => void, thisArg?: any): void;
-            map<TTarget>(mapFuction: (item: Immutable<T>, index: number, array: Immutable<T[]>) => TTarget): Immutable<TTarget[]>;
+            forEach(
+                callbackfn: (value: Immutable<T>, index: number, array: Immutable<T[]>) => void,
+                thisArg?: any,
+            ): void;
+            map<TTarget>(
+                mapFuction: (item: Immutable<T>, index: number, array: Immutable<T[]>) => TTarget,
+            ): Immutable<TTarget[]>;
             filter(filterFunction: (item: Immutable<T>, index: number) => boolean): Immutable<T[]>;
             slice(start?: number, end?: number): Immutable<T[]>;
-            concat(...arr: Array<T|T[]|Immutable<T>|Array<Immutable<T>>|Immutable<T[]>>): Immutable<T[]>;
-            reduce(callbackfn: (previousValue: Immutable<T>, currentValue: Immutable<T>, currentIndex: number, array: Immutable<T[]>) => T): Immutable<T>;
-            reduce<TTarget>(callbackfn: (previousValue: TTarget, currentValue: Immutable<T>, currentIndex: number, array: Immutable<T[]>) => TTarget, initialValue?: TTarget): Immutable<TTarget>;
-            reduceRight(callbackfn: (previousValue: Immutable<T>, currentValue: Immutable<T>, currentIndex: number, array: Immutable<T[]>) => T): Immutable<T>;
-            reduceRight<TTarget>(callbackfn: (previousValue: TTarget, currentValue: Immutable<T>, currentIndex: number, array: Immutable<T[]>) => TTarget, initialValue?: TTarget): Immutable<TTarget>;
+            concat(...arr: Array<T | T[] | Immutable<T> | Array<Immutable<T>> | Immutable<T[]>>): Immutable<T[]>;
+            reduce(
+                callbackfn: (
+                    previousValue: Immutable<T>,
+                    currentValue: Immutable<T>,
+                    currentIndex: number,
+                    array: Immutable<T[]>,
+                ) => T,
+            ): Immutable<T>;
+            reduce<TTarget>(
+                callbackfn: (
+                    previousValue: TTarget,
+                    currentValue: Immutable<T>,
+                    currentIndex: number,
+                    array: Immutable<T[]>,
+                ) => TTarget,
+                initialValue?: TTarget,
+            ): Immutable<TTarget>;
+            reduceRight(
+                callbackfn: (
+                    previousValue: Immutable<T>,
+                    currentValue: Immutable<T>,
+                    currentIndex: number,
+                    array: Immutable<T[]>,
+                ) => T,
+            ): Immutable<T>;
+            reduceRight<TTarget>(
+                callbackfn: (
+                    previousValue: TTarget,
+                    currentValue: Immutable<T>,
+                    currentIndex: number,
+                    array: Immutable<T[]>,
+                ) => TTarget,
+                initialValue?: TTarget,
+            ): Immutable<TTarget>;
         }
@@ -133,6 +242,9 @@
         /** These methods are banned by seamless-immutable. */
-        type MutatingArrayMethods = Extract<keyof any[], 'push' | 'pop' | 'sort' | 'splice' | 'shift' | 'unshift' | 'reverse' | number>;
+        type MutatingArrayMethods = Extract<
+            keyof any[],
+            "push" | "pop" | "sort" | "splice" | "shift" | "unshift" | "reverse" | number
+        >;
 
         /** NOTE: These methods mutate data, but seamless-immutable does not ban them. We will ban them in our type definitions. */
-        type AdditionalMutatingArrayMethods = Extract<keyof any[], 'copyWithin' | 'fill'>;
+        type AdditionalMutatingArrayMethods = Extract<keyof any[], "copyWithin" | "fill">;
 
@@ -152,5 +264,21 @@ /** The remaining properties on Array<T>, after we remove the mutating functions and the wrapped non-mutating functions. */
         // These methods are banned by seamless-immutable
-        type MutatingDateMethods = Extract<keyof Date, 'setDate' | 'setFullYear' | 'setHours' | 'setMilliseconds' | 'setMinutes' | 'setMonth' | 'setSeconds' |
-            'setTime' | 'setUTCDate' | 'setUTCFullYear' | 'setUTCHours' | 'setUTCMilliseconds' | 'setUTCMinutes' |
-            'setUTCMonth' | 'setUTCSeconds' | 'setYear'>;
+        type MutatingDateMethods = Extract<
+            keyof Date,
+            | "setDate"
+            | "setFullYear"
+            | "setHours"
+            | "setMilliseconds"
+            | "setMinutes"
+            | "setMonth"
+            | "setSeconds"
+            | "setTime"
+            | "setUTCDate"
+            | "setUTCFullYear"
+            | "setUTCHours"
+            | "setUTCMilliseconds"
+            | "setUTCMinutes"
+            | "setUTCMonth"
+            | "setUTCSeconds"
+            | "setYear"
+        >;
 
@@ -161,5 +289,4 @@ /** Only allows Date methods, which are the getters. */
 
-    type Immutable<T, O extends object = {}> =
-        T extends Promise<infer U> ? Promise<Immutable.MakeImmutable<U, O>> :
-        Immutable.MakeImmutable<T, O>;
+    type Immutable<T, O extends object = {}> = T extends Promise<infer U> ? Promise<Immutable.MakeImmutable<U, O>>
+        : Immutable.MakeImmutable<T, O>;
     namespace Immutable {
@@ -174,7 +301,6 @@ type AnyFunction = (...args: any[]) => any;
 
-        type MakeImmutable<T, O extends object = {}> =
-            T extends CannotMakeImmutable<O> ? T :
-            T extends Array<infer Element> ? ImmutableArray<Element> :
-            T extends Date ? ImmutableDate :
-            ImmutableObject<T>;
+        type MakeImmutable<T, O extends object = {}> = T extends CannotMakeImmutable<O> ? T
+            : T extends Array<infer Element> ? ImmutableArray<Element>
+            : T extends Date ? ImmutableDate
+            : ImmutableObject<T>;
     }
@@ -193,3 +319,6 @@
 
-    function asMutable<T>(obj: T | ImmutableObject<T>, opts?: AsMutableOptions<false>): { [K in keyof T]: Immutable<T[K]> };
+    function asMutable<T>(
+        obj: T | ImmutableObject<T>,
+        opts?: AsMutableOptions<false>,
+    ): { [K in keyof T]: Immutable<T[K]> };
     function asMutable<T>(obj: T | ImmutableObject<T>, opts: AsMutableOptions<true>): T;
@@ -196,0 +325,0 @@ function asMutable<T>(obj: T | ImmutableObject<T>, opts: AsMutableOptions): T | { [K in keyof T]: Immutable<T[K]> };

seamless-immutable/package.json

 {
     "name": "@types/seamless-immutable",
-    "version": "7.1.16",
+    "version": "7.1.17",
     "description": "TypeScript definitions for Seamless-immutable",
@@ -43,4 +43,4 @@ "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/seamless-immutable",
     "dependencies": {},
-    "typesPublisherContentHash": "0d5ca84a1acbe1ffa0377fff6fd161edbcccda792586c62b4173d8a6d0ed3c6d",
-    "typeScriptVersion": "3.6"
+    "typesPublisherContentHash": "58a0cd39b2d81fc863ed316197f7b483e7e3dd886a6ed5650d18dbbc224e70dc",
+    "typeScriptVersion": "4.5"
 }

seamless-immutable/README.md

@@ -11,3 +11,3 @@ # Installation
 ### Additional Details
- * Last updated: Tue, 06 Jul 2021 16:34:25 GMT
+ * Last updated: Mon, 25 Sep 2023 13:39:06 GMT
  * Dependencies: none
@@ -14,0 +14,0 @@ * Global values: none

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

17010

increased by10.91%

Lines of code

280

increased by85.43%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes