mobx 6.1.8 → 6.9.0

package/src/api/iscomputed.ts

@@ -1,25 +1,31 @@
 import { $mobx, getAtom, isComputedValue, isObservableObject, die, isStringish } from "../internal"
 
 export function _isComputed(value, property?: PropertyKey): boolean {
-    if (property !== undefined) {
-        if (isObservableObject(value) === false) return false
-        if (!value[$mobx].values_.has(property)) return false
-        const atom = getAtom(value, property)
-        return isComputedValue(atom)
+    if (property === undefined) {
+        return isComputedValue(value)
     }
-    return isComputedValue(value)
+    if (isObservableObject(value) === false) {
+        return false
+    }
+    if (!value[$mobx].values_.has(property)) {
+        return false
+    }
+    const atom = getAtom(value, property)
+    return isComputedValue(atom)
 }
 
 export function isComputed(value: any): boolean {
-    if (__DEV__ && arguments.length > 1)
+    if (__DEV__ && arguments.length > 1) {
         return die(
             `isComputed expects only 1 argument. Use isComputedProp to inspect the observability of a property`
         )
+    }
     return _isComputed(value)
 }
 
 export function isComputedProp(value: any, propName: PropertyKey): boolean {
-    if (__DEV__ && !isStringish(propName))
+    if (__DEV__ && !isStringish(propName)) {
         return die(`isComputed expected a property name as second argument`)
+    }
     return _isComputed(value, propName)
 }

package/src/api/isobservable.ts

@@ -11,12 +11,15 @@ import {
 } from "../internal"
 
 function _isObservable(value, property?: PropertyKey): boolean {
-    if (!value) return false
+    if (!value) {
+        return false
+    }
     if (property !== undefined) {
-        if (__DEV__ && (isObservableMap(value) || isObservableArray(value)))
+        if (__DEV__ && (isObservableMap(value) || isObservableArray(value))) {
             return die(
                 "isObservable(object, propertyName) is not supported for arrays and maps. Use map.has or array.length instead."
             )
+        }
         if (isObservableObject(value)) {
             return value[$mobx].values_.has(property)
         }
@@ -33,14 +36,17 @@ function _isObservable(value, property?: PropertyKey): boolean {
 }
 
 export function isObservable(value: any): boolean {
-    if (__DEV__ && arguments.length !== 1)
+    if (__DEV__ && arguments.length !== 1) {
         die(
             `isObservable expects only 1 argument. Use isObservableProp to inspect the observability of a property`
         )
+    }
     return _isObservable(value)
 }
 
 export function isObservableProp(value: any, propName: PropertyKey): boolean {
-    if (__DEV__ && !isStringish(propName)) return die(`expected a property name as second argument`)
+    if (__DEV__ && !isStringish(propName)) {
+        return die(`expected a property name as second argument`)
+    }
     return _isObservable(value, propName)
 }

package/src/api/makeObservable.ts

@@ -11,9 +11,9 @@ import {
     isObservableObject,
     die,
     ownKeys,
-    objectPrototype,
-    inferredAnnotationsSymbol,
-    extendObservable
+    extendObservable,
+    addHiddenProp,
+    storedAnnotationsSymbol
 } from "../internal"
 
 // Hack based on https://github.com/Microsoft/TypeScript/issues/14829#issuecomment-322267089
@@ -31,6 +31,11 @@ export function makeObservable<T extends object, AdditionalKeys extends Property
     const adm: ObservableObjectAdministration = asObservableObject(target, options)[$mobx]
     startBatch()
     try {
+        if (__DEV__ && annotations && target[storedAnnotationsSymbol]) {
+            die(
+                `makeObservable second arg must be nullish when using decorators. Mixing @decorator syntax with annotations is not supported.`
+            )
+        }
         // Default to decorators
         annotations ??= collectStoredAnnotations(target)
 
@@ -42,56 +47,50 @@ export function makeObservable<T extends object, AdditionalKeys extends Property
     return target
 }
 
+// proto[keysSymbol] = new Set<PropertyKey>()
+const keysSymbol = Symbol("mobx-keys")
+
 export function makeAutoObservable<T extends object, AdditionalKeys extends PropertyKey = never>(
     target: T,
     overrides?: AnnotationsMap<T, NoInfer<AdditionalKeys>>,
     options?: CreateObservableOptions
 ): T {
     if (__DEV__) {
-        if (!isPlainObject(target) && !isPlainObject(Object.getPrototypeOf(target)))
+        if (!isPlainObject(target) && !isPlainObject(Object.getPrototypeOf(target))) {
             die(`'makeAutoObservable' can only be used for classes that don't have a superclass`)
-        if (isObservableObject(target))
+        }
+        if (isObservableObject(target)) {
             die(`makeAutoObservable can only be used on objects not already made observable`)
+        }
     }
 
-    // Optimization (avoids visiting protos)
-    // assumes that annotation.make_/.extend_ works the same for plain objects
+    // Optimization: avoid visiting protos
+    // Assumes that annotation.make_/.extend_ works the same for plain objects
     if (isPlainObject(target)) {
         return extendObservable(target, target, overrides, options)
     }
 
     const adm: ObservableObjectAdministration = asObservableObject(target, options)[$mobx]
+
+    // Optimization: cache keys on proto
+    // Assumes makeAutoObservable can be called only once per object and can't be used in subclass
+    if (!target[keysSymbol]) {
+        const proto = Object.getPrototypeOf(target)
+        const keys = new Set([...ownKeys(target), ...ownKeys(proto)])
+        keys.delete("constructor")
+        keys.delete($mobx)
+        addHiddenProp(proto, keysSymbol, keys)
+    }
+
     startBatch()
     try {
-        // Use cached inferred annotations if available (only in classes)
-        if (target[inferredAnnotationsSymbol]) {
-            target[inferredAnnotationsSymbol].forEach((value, key) => adm.make_(key, value))
-            // Overrides are not cached, unless `true`, see #2832
-            if (overrides) {
-                ownKeys(overrides).forEach(key => {
-                    const annotation = overrides[key]
-                    if (annotation !== true) {
-                        adm.make_(key, annotation)
-                    }
-                })
-            }
-        } else {
-            const ignoreKeys = { [$mobx]: 1, [inferredAnnotationsSymbol]: 1, constructor: 1 }
-            const make = key => {
-                if (ignoreKeys[key]) return
-                ignoreKeys[key] = 1
-                adm.make_(
-                    key,
-                    // must pass "undefined" for { key: undefined }
-                    !overrides ? true : key in overrides ? overrides[key] : true
-                )
-            }
-            let current = target
-            while (current && current !== objectPrototype) {
-                ownKeys(current).forEach(make)
-                current = Object.getPrototypeOf(current)
-            }
-        }
+        target[keysSymbol].forEach(key =>
+            adm.make_(
+                key,
+                // must pass "undefined" for { key: undefined }
+                !overrides ? true : key in overrides ? overrides[key] : true
+            )
+        )
     } finally {
         endBatch()
     }

package/src/api/object-api.ts

@@ -20,9 +20,9 @@ export function keys<T>(set: ObservableSet<T>): ReadonlyArray<T>
 export function keys<T extends Object>(obj: T): ReadonlyArray<PropertyKey>
 export function keys(obj: any): any {
     if (isObservableObject(obj)) {
-        return (((obj as any) as IIsObservableObject)[
-            $mobx
-        ] as ObservableObjectAdministration).keys_()
+        return (
+            (obj as any as IIsObservableObject)[$mobx] as ObservableObjectAdministration
+        ).keys_()
     }
     if (isObservableMap(obj) || isObservableSet(obj)) {
         return Array.from(obj.keys())
@@ -86,26 +86,36 @@ export function set(obj: any, key: any, value?: any): void {
         startBatch()
         const values = key
         try {
-            for (let key in values) set(obj, key, values[key])
+            for (let key in values) {
+                set(obj, key, values[key])
+            }
         } finally {
             endBatch()
         }
         return
     }
     if (isObservableObject(obj)) {
-        ;((obj as any) as IIsObservableObject)[$mobx].set_(key, value)
+        ;(obj as any as IIsObservableObject)[$mobx].set_(key, value)
     } else if (isObservableMap(obj)) {
         obj.set(key, value)
     } else if (isObservableSet(obj)) {
         obj.add(key)
     } else if (isObservableArray(obj)) {
-        if (typeof key !== "number") key = parseInt(key, 10)
-        if (key < 0) die(`Invalid index: '${key}'`)
+        if (typeof key !== "number") {
+            key = parseInt(key, 10)
+        }
+        if (key < 0) {
+            die(`Invalid index: '${key}'`)
+        }
         startBatch()
-        if (key >= obj.length) obj.length = key + 1
+        if (key >= obj.length) {
+            obj.length = key + 1
+        }
         obj[key] = value
         endBatch()
-    } else die(8)
+    } else {
+        die(8)
+    }
 }
 
 export function remove<K, V>(obj: ObservableMap<K, V>, key: K)
@@ -114,13 +124,15 @@ export function remove<T>(obj: IObservableArray<T>, index: number)
 export function remove<T extends Object>(obj: T, key: string)
 export function remove(obj: any, key: any): void {
     if (isObservableObject(obj)) {
-        ;((obj as any) as IIsObservableObject)[$mobx].delete_(key)
+        ;(obj as any as IIsObservableObject)[$mobx].delete_(key)
     } else if (isObservableMap(obj)) {
         obj.delete(key)
     } else if (isObservableSet(obj)) {
         obj.delete(key)
     } else if (isObservableArray(obj)) {
-        if (typeof key !== "number") key = parseInt(key, 10)
+        if (typeof key !== "number") {
+            key = parseInt(key, 10)
+        }
         obj.splice(key, 1)
     } else {
         die(9)
@@ -133,7 +145,7 @@ export function has<T>(obj: IObservableArray<T>, index: number): boolean
 export function has<T extends Object>(obj: T, key: string): boolean
 export function has(obj: any, key: any): boolean {
     if (isObservableObject(obj)) {
-        return ((obj as any) as IIsObservableObject)[$mobx].has_(key)
+        return (obj as any as IIsObservableObject)[$mobx].has_(key)
     } else if (isObservableMap(obj)) {
         return obj.has(key)
     } else if (isObservableSet(obj)) {
@@ -148,9 +160,11 @@ export function get<K, V>(obj: ObservableMap<K, V>, key: K): V | undefined
 export function get<T>(obj: IObservableArray<T>, index: number): T | undefined
 export function get<T extends Object>(obj: T, key: string): any
 export function get(obj: any, key: any): any {
-    if (!has(obj, key)) return undefined
+    if (!has(obj, key)) {
+        return undefined
+    }
     if (isObservableObject(obj)) {
-        return ((obj as any) as IIsObservableObject)[$mobx].get_(key)
+        return (obj as any as IIsObservableObject)[$mobx].get_(key)
     } else if (isObservableMap(obj)) {
         return obj.get(key)
     } else if (isObservableArray(obj)) {
@@ -158,3 +172,17 @@ export function get(obj: any, key: any): any {
     }
     die(11)
 }
+
+export function apiDefineProperty(obj: Object, key: PropertyKey, descriptor: PropertyDescriptor) {
+    if (isObservableObject(obj)) {
+        return (obj as any as IIsObservableObject)[$mobx].defineProperty_(key, descriptor)
+    }
+    die(39)
+}
+
+export function apiOwnKeys(obj: Object) {
+    if (isObservableObject(obj)) {
+        return (obj as any as IIsObservableObject)[$mobx].ownKeys_()
+    }
+    die(38)
+}

package/src/api/observable.ts

@@ -28,7 +28,8 @@ import {
     globalState,
     assign,
     isStringish,
-    createObservableAnnotation
+    createObservableAnnotation,
+    createAutoAnnotation
 } from "../internal"
 
 export const OBSERVABLE = "observable"
@@ -59,14 +60,14 @@ export function asCreateObservableOptions(thing: any): CreateObservableOptions {
     return thing || defaultCreateObservableOptions
 }
 
-const observableAnnotation = createObservableAnnotation("observable")
-const observableRefAnnotation = createObservableAnnotation("observable.ref", {
+const observableAnnotation = createObservableAnnotation(OBSERVABLE)
+const observableRefAnnotation = createObservableAnnotation(OBSERVABLE_REF, {
     enhancer: referenceEnhancer
 })
-const observableShallowAnnotation = createObservableAnnotation("observable.shallow", {
+const observableShallowAnnotation = createObservableAnnotation(OBSERVABLE_SHALLOW, {
     enhancer: shallowEnhancer
 })
-const observableStructAnnotation = createObservableAnnotation("observable.struct", {
+const observableStructAnnotation = createObservableAnnotation(OBSERVABLE_STRUCT, {
     enhancer: refStructEnhancer
 })
 const observableDecoratorAnnotation = createDecoratorAnnotation(observableAnnotation)
@@ -82,13 +83,7 @@ export function getEnhancerFromOptions(options: CreateObservableOptions): IEnhan
 export function getAnnotationFromOptions(
     options?: CreateObservableOptions
 ): Annotation | undefined {
-    return options
-        ? options.deep === true
-            ? observableAnnotation
-            : options.deep === false
-            ? observableRefAnnotation
-            : options.defaultDecorator
-        : undefined
+    return options ? options.defaultDecorator ?? createAutoAnnotation(options) : undefined
 }
 
 export function getEnhancerFromAnnotation(annotation?: Annotation): IEnhancer<any> {
@@ -107,27 +102,44 @@ function createObservable(v: any, arg2?: any, arg3?: any) {
     }
 
     // already observable - ignore
-    if (isObservable(v)) return v
+    if (isObservable(v)) {
+        return v
+    }
 
     // plain object
-    if (isPlainObject(v)) return observable.object(v, arg2, arg3)
+    if (isPlainObject(v)) {
+        return observable.object(v, arg2, arg3)
+    }
 
     // Array
-    if (Array.isArray(v)) return observable.array(v, arg2)
+    if (Array.isArray(v)) {
+        return observable.array(v, arg2)
+    }
 
     // Map
-    if (isES6Map(v)) return observable.map(v, arg2)
+    if (isES6Map(v)) {
+        return observable.map(v, arg2)
+    }
 
     // Set
-    if (isES6Set(v)) return observable.set(v, arg2)
+    if (isES6Set(v)) {
+        return observable.set(v, arg2)
+    }
 
     // other object - ignore
-    if (typeof v === "object" && v !== null) return v
+    if (typeof v === "object" && v !== null) {
+        return v
+    }
 
     // anything else
     return observable.box(v, arg2)
 }
-Object.assign(createObservable, observableDecoratorAnnotation)
+assign(createObservable, observableDecoratorAnnotation)
+
+export interface IObservableValueFactory {
+    <T>(value: T, options?: CreateObservableOptions): IObservableValue<T>
+    <T>(value?: T, options?: CreateObservableOptions): IObservableValue<T | undefined>
+}
 
 export interface IObservableFactory extends Annotation, PropertyDecorator {
     <T = any>(value: T[], options?: CreateObservableOptions): IObservableArray<T>
@@ -139,7 +151,7 @@ export interface IObservableFactory extends Annotation, PropertyDecorator {
         options?: CreateObservableOptions
     ): T
 
-    box: <T = any>(value?: T, options?: CreateObservableOptions) => IObservableValue<T>
+    box: IObservableValueFactory
     array: <T = any>(initialValues?: T[], options?: CreateObservableOptions) => IObservableArray<T>
     set: <T = any>(
         initialValues?: IObservableSetInitialValues<T>,
@@ -168,15 +180,17 @@ export interface IObservableFactory extends Annotation, PropertyDecorator {
 }
 
 const observableFactories: IObservableFactory = {
-    box<T = any>(value?: T, options?: CreateObservableOptions): IObservableValue<T> {
+    box<T = any>(value: T, options?: CreateObservableOptions): IObservableValue<T> {
         const o = asCreateObservableOptions(options)
         return new ObservableValue(value, getEnhancerFromOptions(o), o.name, true, o.equals)
     },
     array<T = any>(initialValues?: T[], options?: CreateObservableOptions): IObservableArray<T> {
         const o = asCreateObservableOptions(options)
-        return (globalState.useProxies === false || o.proxy === false
-            ? createLegacyArray
-            : createObservableArray)(initialValues, getEnhancerFromOptions(o), o.name)
+        return (
+            globalState.useProxies === false || o.proxy === false
+                ? createLegacyArray
+                : createObservableArray
+        )(initialValues, getEnhancerFromOptions(o), o.name)
     },
     map<K = any, V = any>(
         initialValues?: IObservableMapInitialValues<K, V>,
@@ -192,7 +206,7 @@ const observableFactories: IObservableFactory = {
         const o = asCreateObservableOptions(options)
         return new ObservableSet<T>(initialValues, getEnhancerFromOptions(o), o.name)
     },
-    object<T = any>(
+    object<T extends object = any>(
         props: T,
         decorators?: AnnotationsMap<T, never>,
         options?: CreateObservableOptions

package/src/api/observe.ts

@@ -20,22 +20,23 @@ export function observe<T>(
     fireImmediately?: boolean
 ): Lambda
 export function observe<T>(
-    observableArray: IObservableArray<T>,
+    observableArray: IObservableArray<T> | Array<T>,
     listener: (change: IArrayDidChange<T>) => void,
     fireImmediately?: boolean
 ): Lambda
 export function observe<V>(
-    observableMap: ObservableSet<V>,
+    // ObservableSet/ObservableMap are required despite they implement Set/Map: https://github.com/mobxjs/mobx/pull/3180#discussion_r746542929
+    observableSet: ObservableSet<V> | Set<V>,
     listener: (change: ISetDidChange<V>) => void,
     fireImmediately?: boolean
 ): Lambda
 export function observe<K, V>(
-    observableMap: ObservableMap<K, V>,
+    observableMap: ObservableMap<K, V> | Map<K, V>,
     listener: (change: IMapDidChange<K, V>) => void,
     fireImmediately?: boolean
 ): Lambda
 export function observe<K, V>(
-    observableMap: ObservableMap<K, V>,
+    observableMap: ObservableMap<K, V> | Map<K, V>,
     property: K,
     listener: (change: IValueDidChange<V>) => void,
     fireImmediately?: boolean
@@ -52,9 +53,11 @@ export function observe<T, K extends keyof T>(
     fireImmediately?: boolean
 ): Lambda
 export function observe(thing, propOrCb?, cbOrFire?, fireImmediately?): Lambda {
-    if (isFunction(cbOrFire))
+    if (isFunction(cbOrFire)) {
         return observeObservableProperty(thing, propOrCb, cbOrFire, fireImmediately)
-    else return observeObservable(thing, propOrCb, cbOrFire)
+    } else {
+        return observeObservable(thing, propOrCb, cbOrFire)
+    }
 }
 
 function observeObservable(thing, listener, fireImmediately: boolean) {

package/src/api/tojs.ts

@@ -1,12 +1,13 @@
 import {
-    keys,
     isObservable,
     isObservableArray,
     isObservableValue,
     isObservableMap,
     isObservableSet,
-    getPlainObjectKeys,
-    die
+    isComputedValue,
+    die,
+    apiOwnKeys,
+    objectPrototype
 } from "../internal"
 
 function cache<K, V>(map: Map<any, any>, key: K, value: V): V {
@@ -20,10 +21,13 @@ function toJSHelper(source, __alreadySeen: Map<any, any>) {
         typeof source !== "object" ||
         source instanceof Date ||
         !isObservable(source)
-    )
+    ) {
         return source
+    }
 
-    if (isObservableValue(source)) return toJSHelper(source.get(), __alreadySeen)
+    if (isObservableValue(source) || isComputedValue(source)) {
+        return toJSHelper(source.get(), __alreadySeen)
+    }
     if (__alreadySeen.has(source)) {
         return __alreadySeen.get(source)
     }
@@ -49,19 +53,25 @@ function toJSHelper(source, __alreadySeen: Map<any, any>) {
         return res
     } else {
         // must be observable object
-        keys(source) // make sure keys are observed
         const res = cache(__alreadySeen, source, {})
-        getPlainObjectKeys(source).forEach((key: any) => {
-            res[key] = toJSHelper(source[key], __alreadySeen)
+        apiOwnKeys(source).forEach((key: any) => {
+            if (objectPrototype.propertyIsEnumerable.call(source, key)) {
+                res[key] = toJSHelper(source[key], __alreadySeen)
+            }
         })
         return res
     }
 }
 
 /**
- * Basically, a deep clone, so that no reactive property will exist anymore.
+ * Recursively converts an observable to it's non-observable native counterpart.
+ * It does NOT recurse into non-observables, these are left as they are, even if they contain observables.
+ * Computed and other non-enumerable properties are completely ignored.
+ * Complex scenarios require custom solution, eg implementing `toJSON` or using `serializr` lib.
  */
 export function toJS<T>(source: T, options?: any): T {
-    if (__DEV__ && options) die("toJS no longer supports options")
+    if (__DEV__ && options) {
+        die("toJS no longer supports options")
+    }
     return toJSHelper(source, new Map())
 }

package/src/api/trace.ts

@@ -4,9 +4,13 @@ export function trace(thing?: any, prop?: string, enterBreakPoint?: boolean): vo
 export function trace(thing?: any, enterBreakPoint?: boolean): void
 export function trace(enterBreakPoint?: boolean): void
 export function trace(...args: any[]): void {
-    if (!__DEV__) die(`trace() is not available in production builds`)
+    if (!__DEV__) {
+        die(`trace() is not available in production builds`)
+    }
     let enterBreakPoint = false
-    if (typeof args[args.length - 1] === "boolean") enterBreakPoint = args.pop()
+    if (typeof args[args.length - 1] === "boolean") {
+        enterBreakPoint = args.pop()
+    }
     const derivation = getAtomFromArgs(args)
     if (!derivation) {
         return die(

package/src/api/when.ts

@@ -9,10 +9,19 @@ import {
     allowStateChanges
 } from "../internal"
 
+// https://github.com/mobxjs/mobx/issues/3582
+interface GenericAbortSignal {
+    readonly aborted: boolean
+    onabort?: ((...args: any) => any) | null
+    addEventListener?: (...args: any) => any
+    removeEventListener?: (...args: any) => any
+}
+
 export interface IWhenOptions {
     name?: string
     timeout?: number
     onError?: (error: any) => void
+    signal?: GenericAbortSignal
 }
 
 export function when(
@@ -25,20 +34,24 @@ export function when(
     opts?: IWhenOptions
 ): IReactionDisposer
 export function when(predicate: any, arg1?: any, arg2?: any): any {
-    if (arguments.length === 1 || (arg1 && typeof arg1 === "object"))
+    if (arguments.length === 1 || (arg1 && typeof arg1 === "object")) {
         return whenPromise(predicate, arg1)
+    }
     return _when(predicate, arg1, arg2 || {})
 }
 
 function _when(predicate: () => boolean, effect: Lambda, opts: IWhenOptions): IReactionDisposer {
     let timeoutHandle: any
     if (typeof opts.timeout === "number") {
+        const error = new Error("WHEN_TIMEOUT")
         timeoutHandle = setTimeout(() => {
             if (!disposer[$mobx].isDisposed_) {
                 disposer()
-                const error = new Error("WHEN_TIMEOUT")
-                if (opts.onError) opts.onError(error)
-                else throw error
+                if (opts.onError) {
+                    opts.onError(error)
+                } else {
+                    throw error
+                }
             }
         }, opts.timeout)
     }
@@ -54,7 +67,9 @@ function _when(predicate: () => boolean, effect: Lambda, opts: IWhenOptions): IR
         let cond = allowStateChanges(false, predicate)
         if (cond) {
             r.dispose()
-            if (timeoutHandle) clearTimeout(timeoutHandle)
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle)
+            }
             effectAction()
         }
     }, opts)
@@ -65,16 +80,26 @@ function whenPromise(
     predicate: () => boolean,
     opts?: IWhenOptions
 ): Promise<void> & { cancel(): void } {
-    if (__DEV__ && opts && opts.onError)
+    if (__DEV__ && opts && opts.onError) {
         return die(`the options 'onError' and 'promise' cannot be combined`)
+    }
+    if (opts?.signal?.aborted) {
+        return Object.assign(Promise.reject(new Error("WHEN_ABORTED")), { cancel: () => null })
+    }
     let cancel
+    let abort
     const res = new Promise((resolve, reject) => {
-        let disposer = _when(predicate, resolve, { ...opts, onError: reject })
+        let disposer = _when(predicate, resolve as Lambda, { ...opts, onError: reject })
         cancel = () => {
             disposer()
-            reject("WHEN_CANCELLED")
+            reject(new Error("WHEN_CANCELLED"))
+        }
+        abort = () => {
+            disposer()
+            reject(new Error("WHEN_ABORTED"))
         }
-    })
+        opts?.signal?.addEventListener?.("abort", abort)
+    }).finally(() => opts?.signal?.removeEventListener?.("abort", abort))
     ;(res as any).cancel = cancel
     return res as any
 }