@types/knockout.mapping 2.0.33 → 2.0.37

knockout.mapping/LICENSE

@@ -1,6 +1,6 @@
     MIT License
 
-    Copyright (c) Microsoft Corporation. All rights reserved.
+    Copyright (c) Microsoft Corporation.
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"), to deal

knockout.mapping/README.md

@@ -5,13 +5,12 @@
 This package contains type definitions for Knockout.Mapping (https://github.com/SteveSanderson/knockout.mapping).
 
 # Details
-Files were exported from https://www.github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/knockout.mapping
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/knockout.mapping.
 
-Additional Details
- * Last updated: Wed, 28 Feb 2018 23:22:44 GMT
- * Dependencies: knockout
- * Global values: mapping
+### Additional Details
+ * Last updated: Tue, 11 Jan 2022 16:31:41 GMT
+ * Dependencies: [@types/knockout](https://npmjs.com/package/@types/knockout)
+ * Global values: `mapping`
 
 # Credits
-These definitions were written by Boris Yankov <https://github.com/borisyankov>, 
-//                 Mathias Lorenzen <https://github.com/ffMathy>.
+These definitions were written by [Boris Yankov](https://github.com/borisyankov), [Mathias Lorenzen](https://github.com/ffMathy), and [Leonardo Lombardi](https://github.com/ltlombardi).

knockout.mapping/index.d.ts

@@ -1,9 +1,10 @@
 // Type definitions for Knockout.Mapping 2.0
 // Project: https://github.com/SteveSanderson/knockout.mapping
-// Definitions by: Boris Yankov <https://github.com/borisyankov>, 
+// Definitions by: Boris Yankov <https://github.com/borisyankov> 
 //                 Mathias Lorenzen <https://github.com/ffMathy>
+//                 Leonardo Lombardi <https://github.com/ltlombardi>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.8
 
 /// <reference types="knockout" />
 
@@ -12,11 +13,48 @@ export as namespace mapping;
 declare var self: KnockoutMapping;
 export = self;
 
+type Primitives = string | number | boolean | symbol;
+
 declare global {
-    type KnockoutObservableType<T> = {	
-        [P in keyof T]: KnockoutObservable<KnockoutObservableType<T[P]>>|T[P];	
+
+    type MappedType<T> =
+        [T] extends [Primitives] ? KnockoutObservable<T> :
+        [T] extends [object] ? KnockoutObservableType<T> :
+        any;
+
+    type KnockoutObservableType<T> = {
+        [P in keyof T]: T[P] extends Primitives ? KnockoutObservable<T[P]> :
+                        T[P] extends any[] ? KnockoutObservableArrayType<T[P][number]> :
+                        T[P] extends ReadonlyArray<any> ? KnockoutReadonlyObservableArrayType<T[P][number]> :
+                        MappedType<T[P]>;
     };
-    
+
+    // Could not get this to return any when T is any. It returns a Union type of the possible values.
+    type KnockoutObservableArrayType<T> = T extends Primitives ? KnockoutObservableArray<T> : KnockoutObservableArray<KnockoutObservableType<T>>;
+
+    type KnockoutReadonlyObservableArrayType<T> = T extends Primitives ? KnockoutReadonlyObservableArray<T> : KnockoutReadonlyObservableArray<KnockoutObservableType<T>>;
+
+    type KnockoutMappingOptions<T> = KnockoutMappingSpecificOptions<T> | KnockoutMappingStandardOptions;
+
+    interface KnockoutMappingStandardOptions {
+        ignore?: string[] | undefined;
+        include?: string[] | undefined;
+        copy?: string[] | undefined;
+        observe?: string[] | undefined;
+        mappedProperties?: string[] | undefined; // Undocumented
+        deferEvaluation?: boolean | undefined; // Undocumented
+    }
+
+    type KnockoutMappingSpecificOptions<T> = {
+        [P in keyof T]?: KnockoutPropertyMappingCallBack
+    }
+
+    interface KnockoutPropertyMappingCallBack {
+        create?: ((options: KnockoutMappingCreateOptions) => void) | undefined;
+        update?: ((options: KnockoutMappingUpdateOptions) => void) | undefined;
+        key?: ((data: any) => any) | undefined;
+    }
+
     interface KnockoutMappingCreateOptions {
         data: any;
         parent: any;
@@ -26,39 +64,107 @@ declare global {
         data: any;
         parent: any;
         target: any;
-        observable?: KnockoutObservable<any>;
-    }
-
-    interface KnockoutMappingOptions {
-        ignore?: string[];
-        include?: string[];
-        copy?: string[];
-        mappedProperties?: string[];
-        deferEvaluation?: boolean;
-        create?: (options: KnockoutMappingCreateOptions) => void;
-        update?: (options: KnockoutMappingUpdateOptions) => void;
-        key?: (data: any) => any;
+        observable?: KnockoutObservable<any> | undefined;
     }
 
     interface KnockoutMapping {
+        /**
+         * Checks if an object was created using KnockoutMapping
+         * @param viewModel View model object to be checked.
+         */
         isMapped(viewModel: any): boolean;
-        fromJS<T>(jsObject: T[]): KnockoutObservableArray<KnockoutObservableType<T>>;
-        fromJS<T>(jsObject: T[], targetOrOptions: any): KnockoutObservableArray<KnockoutObservableType<T>>;
-        fromJS<T>(jsObject: T[], inputOptions: any, target: any): KnockoutObservableArray<KnockoutObservableType<T>>;
-        fromJS<T>(jsObject: T): KnockoutObservableType<T>;
-        fromJS<T>(jsObject: T, targetOrOptions: any): KnockoutObservableType<T>;
-        fromJS<T>(jsObject: T, inputOptions: any, target: any): KnockoutObservableType<T>;
-        fromJSON(jsonString: string): any;
-        fromJSON(jsonString: string, targetOrOptions: any): any;
-        fromJSON(jsonString: string, inputOptions: any, target: any): any;
-        toJS<T>(viewModel: KnockoutObservableArray<T>|KnockoutObservableType<T>[]|KnockoutObservableArray<KnockoutObservableType<T>>|T[], options?: KnockoutMappingOptions): T[];
-        toJS<T>(viewModel: KnockoutObservable<T>|KnockoutObservableType<T>|KnockoutObservable<KnockoutObservableType<T>>, options?: KnockoutMappingOptions): T;
-        toJS<T>(viewModel: T, options?: KnockoutMappingOptions): T;
-        toJSON(rootObject: any, options?: KnockoutMappingOptions): string;
-        defaultOptions(): KnockoutMappingOptions;
+        /**
+         * Creates an observable array view model. Objects on the source array are also converted to observables. Primitive types and arrays are not. 
+         * If 'target' is supplied, instead, target's observable properties are updated.
+         * @param source Array to be mapped.
+         * @param options Options on mapping behavior.
+         * @param target View model object previosly mapped to be updated.
+         */
+        fromJS<T>(source: T[], options?: KnockoutMappingOptions<T[]>, target?: KnockoutObservableArrayType<T>): KnockoutObservableArrayType<T>;
+        /**
+         * Updates target's observable properties with those of the sources.
+         * @param source Array to be mapped.
+         * @param target View model object previosly mapped to be updated.
+         */
+        fromJS<T>(source: T[], target: KnockoutObservableArrayType<T>): KnockoutObservableArrayType<T>;
+        /**
+         * Creates an readonly observable array view model. Objects on the source array are also converted to observables. Primitive types and arrays are not. 
+         * If 'target' is supplied, instead, target's observable properties are updated.
+         * @param source Array to be mapped.
+         * @param options Options on mapping behavior.
+         * @param target View model object previosly mapped to be updated.
+         */
+        fromJS<T>(source: ReadonlyArray<T>, options?: KnockoutMappingOptions<ReadonlyArray<T>>, target?: KnockoutReadonlyObservableArrayType<T>): KnockoutReadonlyObservableArrayType<T>;
+        /**
+         * Updates target's observable properties with those of the sources.
+         * @param source Array to be mapped.
+         * @param target View model object previosly mapped to be updated.
+         */
+        fromJS<T>(source: ReadonlyArray<T>, target: KnockoutReadonlyObservableArrayType<T>): KnockoutReadonlyObservableArrayType<T>;
+        /**
+         * Creates a view model object with observable properties for each of the properties on the source. 
+         * If 'target' is supplied, instead, target's observable properties are updated.
+         * @param source Plain JavaScript object to be mapped.
+         * @param options Options on mapping behavior.
+         * @param target View model object previosly mapped to be updated.
+         */
+        fromJS<T>(source: T, options?: KnockoutMappingOptions<T>, target?: MappedType<T>): MappedType<T>;
+        /**
+         * Updates target's observable properties with those of the sources.
+         * @param source Plain JavaScript object to be mapped.
+         * @param target View model object previosly mapped to be updated.
+         */
+        fromJS<T>(source: T, target: MappedType<T>): MappedType<T>;
+        /**
+         * Creates a view model object with observable properties for each of the properties on the source. 
+         * If 'target' is supplied, instead, target's observable properties are updated.
+         * @param source JSON of a JavaScript object to be mapped.
+         * @param options Options on mapping behavior.
+         * @param target View model object previosly mapped to be updated.
+         */
+        fromJSON(source: string, options?: KnockoutMappingOptions<any>, target?: any): any;
+        /**
+         * Updates target's observable properties with those of the sources.
+         * @param source JSON of a JavaScript object to be mapped.
+         * @param target View model object previosly mapped to be updated.
+         */
+        fromJSON(source: string, target: any): any;
+        /**
+         * Creates an unmapped object containing only the properties of the mapped object that were part of your original JS object. 
+         * @param viewModel View model object previosly mapped.
+         * @param options Options on mapping behavior.
+         */
+        toJS<T>(viewModel: KnockoutObservable<T>, options?: KnockoutMappingOptions<T>): T;
+        toJS<T>(viewModel: KnockoutObservableArray<T>, options?: KnockoutMappingOptions<T>): T[];
+        toJS<T>(viewModel: KnockoutObservableType<T>, options?: KnockoutMappingOptions<T>): T;
+        toJS(viewModel: any, options?: KnockoutMappingOptions<any>): any;
+        /**
+         * Creates an unmapped object containing only the properties of the mapped object that were part of your original JS object. Stringify the result.
+         * @param viewModel Object with observables to be converted.
+         * @param options Options on mapping behavior.
+         */
+        toJSON<T>(viewModel: T, options?: KnockoutMappingOptions<T>): string;
+        /**
+         * Get the default mapping options
+         */
+        defaultOptions(): KnockoutMappingStandardOptions;
+        /**
+         * Undocumented. Reset Mapping default options.
+         */
         resetDefaultOptions(): void;
+        /**
+         * Undocumented. Custom implementation of JavaScript's typeof.
+         * @param x object to check type
+         */
         getType(x: any): any;
-        visitModel(rootObject: any, callback: Function, options?: { visitedObjects?: any; parentName?: string; ignore?: string[]; copy?: string[]; include?: string[]; }): any;
+        /**
+         * Undocumented.
+         */
+        visitModel(
+            rootObject: any,
+            callback: Function,
+            options?: { visitedObjects?: any; parentName?: string | undefined; ignore?: string[] | undefined; copy?: string[] | undefined; include?: string[] | undefined; }
+        ): any;
     }
 
     interface KnockoutObservableArrayFunctions<T> {
@@ -75,7 +181,7 @@ declare global {
         mappedDestroyAll(): void;
     }
 
-    interface KnockoutStatic {
+    interface KnockoutStatic { // this is a declaration merging with knockout's interface
         mapping: KnockoutMapping;
     }
 }

knockout.mapping/package.json

@@ -1,7 +1,8 @@
 {
     "name": "@types/knockout.mapping",
-    "version": "2.0.33",
+    "version": "2.0.37",
     "description": "TypeScript definitions for Knockout.Mapping",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/knockout.mapping",
     "license": "MIT",
     "contributors": [
         {
@@ -10,20 +11,27 @@
             "githubUsername": "borisyankov"
         },
         {
-            "name": "\n//                 Mathias Lorenzen",
+            "name": "Mathias Lorenzen",
             "url": "https://github.com/ffMathy",
             "githubUsername": "ffMathy"
+        },
+        {
+            "name": "Leonardo Lombardi",
+            "url": "https://github.com/ltlombardi",
+            "githubUsername": "ltlombardi"
         }
     ],
     "main": "",
+    "types": "index.d.ts",
     "repository": {
         "type": "git",
-        "url": "https://www.github.com/DefinitelyTyped/DefinitelyTyped.git"
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/knockout.mapping"
     },
     "scripts": {},
     "dependencies": {
         "@types/knockout": "*"
     },
-    "typesPublisherContentHash": "550ebb43379e61b2a9c4e2b3643f55462a5bef0d231b9a5ab8cb68652fc2225a",
-    "typeScriptVersion": "2.3"
+    "typesPublisherContentHash": "6ba47fc51cd64cd605a372e38acf9a3e911e9b9bea060732350546087f8efd55",
+    "typeScriptVersion": "3.8"
 }