@legendapp/state 2.2.0-next.42 → 2.2.0-next.44

package/index.d.ts

@@ -1,4 +1,4 @@
-export { synced, activated } from './src/synced';
+export { activated } from './src/activated';
 export { batch, beginBatch, endBatch } from './src/batching';
 export { computed } from './src/computed';
 export { configureLegendState } from './src/config';
@@ -28,7 +28,7 @@ export declare const internal: {
         isLoadingLocal: boolean;
         isMerging: boolean;
         isLoadingRemote$: import("./src/observableTypes").ObservablePrimitive<boolean>;
-        activateNode: (node: import("./src/observableInterfaces").NodeValue, refresh: () => void, wasPromise: boolean, newValue: any) => {
+        activateNodePersist: (node: import("./src/observableInterfaces").NodeValue, newValue: any) => {
             update: import("./src/observableInterfaces").UpdateFn;
             value: any;
         };
@@ -42,6 +42,6 @@ export declare const internal: {
     set: typeof set;
     setAtPath: typeof setAtPath;
     setNodeValue: typeof setNodeValue;
-    symbolSynced: symbol;
+    symbolActivated: symbol;
     symbolDelete: symbol;
 };

package/index.js

@@ -61,12 +61,12 @@ const symbolGetNode = Symbol('getNode');
 const symbolDelete = /* @__PURE__ */ Symbol('delete');
 const symbolOpaque = Symbol('opaque');
 const optimized = Symbol('optimized');
-const symbolSynced = Symbol('synced');
+const symbolActivated = Symbol('activated');
 const globalState = {
     isLoadingLocal: false,
     isMerging: false,
     isLoadingRemote$: undefined,
-    activateNode: undefined,
+    activateNodePersist: undefined,
     pendingNodes: new Map(),
     dirtyNodes: new Set(),
 };
@@ -91,13 +91,6 @@ function setNodeValue(node, newValue) {
     const isFunc = isFunction(newValue);
     // Compute newValue if newValue is a function or an observable
     newValue = !parentNode.isAssigning && isFunc ? newValue(prevValue) : newValue;
-    // If setting an observable, set a link to the observable instead
-    if (isObservable(newValue)) {
-        const val = newValue;
-        node.lazy = true;
-        node.lazyFn = () => val;
-        newValue = undefined;
-    }
     if (!globalState.isMerging ||
         prevValue === undefined ||
         isFunction(prevValue) ||
@@ -134,7 +127,7 @@ function getNodeValue(node) {
     return child;
 }
 function getChildNode(node, key, asFunction) {
-    var _a;
+    var _a, _b;
     // Get the child by key
     let child = (_a = node.children) === null || _a === void 0 ? void 0 : _a.get(key);
     // Create the child node if it doesn't already exist
@@ -145,11 +138,9 @@ function getChildNode(node, key, asFunction) {
             key,
             lazy: true,
         };
-        if (node.activationState) {
-            const { lookup } = node.activationState;
-            if (lookup) {
-                asFunction = lookup.bind(node, key);
-            }
+        // Lookup functions are bound with the child key
+        if (((_b = node.lazyFn) === null || _b === void 0 ? void 0 : _b.length) === 1) {
+            asFunction = node.lazyFn.bind(node, key);
         }
         if (asFunction) {
             child = Object.assign(() => { }, child);
@@ -164,7 +155,7 @@ function getChildNode(node, key, asFunction) {
 }
 function ensureNodeValue(node) {
     let value = getNodeValue(node);
-    if (!value) {
+    if (!value || isFunction(value)) {
         if (isChildNodeValue(node)) {
             const parent = ensureNodeValue(node.parent);
             value = parent[node.key] = {};
@@ -206,13 +197,11 @@ function extractFunction(node, key, fnOrComputed) {
     node.functions.set(key, fnOrComputed);
 }
 
-function synced(params) {
+function activated(params) {
     return (() => ({
-        [symbolSynced]: params,
+        [symbolActivated]: params,
     }));
 }
-// TODOV3 Remove this for final release
-const activated = synced;
 
 let timeout;
 let numInBatch = 0;
@@ -517,14 +506,6 @@ function opaqueObject(value) {
     }
     return value;
 }
-function getValueAtPath(obj, path) {
-    let o = obj;
-    for (let i = 0; o && i < path.length; i++) {
-        const p = path[i];
-        o = o[p];
-    }
-    return o;
-}
 function setAtPath(obj, path, pathTypes, value, fullObj, restore) {
     let o = obj;
     let oFull = fullObj;
@@ -668,6 +649,7 @@ function setSilently(obs, newValue) {
 }
 
 function onChange(node, callback, options = {}, fromLinks) {
+    var _a;
     const { initial, immediate, noArgs } = options;
     const { trackingType } = options;
     let listeners = immediate ? node.listenersImmediate : node.listeners;
@@ -701,59 +683,36 @@ function onChange(node, callback, options = {}, fromLinks) {
             getPrevious: () => undefined,
         });
     }
-    // TODO: This is really verbose, refactor it to be less code. But for now at least it's correct.
     let extraDisposes;
-    if (node.linkedToNode) {
-        if (!fromLinks || !fromLinks.has(node.linkedToNode)) {
+    function addLinkedNodeListeners(childNode, cb = callback, from) {
+        // Don't add listeners for the same node more than once
+        if (!(fromLinks === null || fromLinks === void 0 ? void 0 : fromLinks.has(childNode))) {
             fromLinks || (fromLinks = new Set());
-            fromLinks.add(node);
-            fromLinks.add(node.linkedToNode);
-            extraDisposes = [onChange(node.linkedToNode, callback, options, fromLinks)];
+            fromLinks.add(from || node);
+            cb || (cb = callback);
+            const childOptions = {
+                trackingType: true,
+                ...options,
+            };
+            // onChange for the linked node
+            extraDisposes = [...(extraDisposes || []), onChange(childNode, cb, childOptions, fromLinks)];
         }
     }
-    // TODO: Need to go up through parents find linked nodes and onChange their nodes at the same path
-    if (node.linkedFromNodes) {
-        for (const linkedFromNode of node.linkedFromNodes) {
-            if (!fromLinks || !fromLinks.has(linkedFromNode)) {
-                fromLinks || (fromLinks = new Set());
-                fromLinks.add(node);
-                fromLinks.add(linkedFromNode);
-                extraDisposes || (extraDisposes = []);
-                extraDisposes.push(onChange(linkedFromNode, callback, options, fromLinks));
-            }
-        }
+    // Add listeners for linked to nodes
+    if (node.linkedToNode) {
+        addLinkedNodeListeners(node.linkedToNode);
     }
+    // Add listeners for linked from nodes
+    (_a = node.linkedFromNodes) === null || _a === void 0 ? void 0 : _a.forEach((linkedFromNode) => addLinkedNodeListeners(linkedFromNode));
+    // Go up through the parents and add listeners for linked from nodes
     let parent = node.parent;
     let pathParent = [node.key];
     while (parent) {
         if (parent.linkedFromNodes) {
             for (const linkedFromNode of parent.linkedFromNodes) {
-                if (!fromLinks || !fromLinks.has(linkedFromNode)) {
-                    fromLinks || (fromLinks = new Set());
-                    fromLinks.add(parent);
-                    fromLinks.add(linkedFromNode);
-                    extraDisposes || (extraDisposes = []);
-                    const path = pathParent;
-                    const p = getValueAtPath(getNodeValue(linkedFromNode), path);
-                    const prev = p ? JSON.parse(JSON.stringify(p)) : {};
-                    const cb = ({ value: valueA }) => {
-                        const value = getValueAtPath(valueA, path);
-                        if (value !== prev) {
-                            callback({
-                                value,
-                                changes: [
-                                    {
-                                        path,
-                                        pathTypes: path.map(() => 'object'), // TODO CHANGE
-                                        prevAtPath: prev,
-                                        valueAtPath: value,
-                                    },
-                                ],
-                                getPrevious: () => prev,
-                            });
-                        }
-                    };
-                    extraDisposes.push(onChange(linkedFromNode, cb, { trackingType: true, ...options }, fromLinks));
+                if (!(fromLinks === null || fromLinks === void 0 ? void 0 : fromLinks.has(linkedFromNode))) {
+                    const cb = createCb(linkedFromNode, pathParent, callback);
+                    addLinkedNodeListeners(linkedFromNode, cb, parent);
                 }
             }
         }
@@ -765,6 +724,38 @@ function onChange(node, callback, options = {}, fromLinks) {
         extraDisposes === null || extraDisposes === void 0 ? void 0 : extraDisposes.forEach((fn) => fn());
     };
 }
+function createCb(linkedFromNode, path, callback) {
+    // Create a callback for a path that calls it with the current value at the path
+    let { valueAtPath: prevAtPath } = getValueAtPath(getNodeValue(linkedFromNode), path);
+    return function ({ value: valueA }) {
+        const { valueAtPath, pathTypes } = getValueAtPath(valueA, path);
+        if (valueAtPath !== prevAtPath) {
+            callback({
+                value: valueAtPath,
+                changes: [
+                    {
+                        path,
+                        pathTypes,
+                        prevAtPath,
+                        valueAtPath,
+                    },
+                ],
+                getPrevious: () => prevAtPath,
+            });
+        }
+        prevAtPath = valueAtPath;
+    };
+}
+function getValueAtPath(obj, path) {
+    let o = obj;
+    const pathTypes = [];
+    for (let i = 0; o && i < path.length; i++) {
+        pathTypes.push(isArray(o) ? 'array' : 'object');
+        const p = path[i];
+        o = o[p];
+    }
+    return { valueAtPath: o, pathTypes };
+}
 
 function setupTracking(nodes, update, noArgs, immediate) {
     let listeners = [];
@@ -973,65 +964,6 @@ function whenReady(predicate, effect) {
     return _when(predicate, effect, true);
 }
 
-function calculateRetryDelay(retryOptions, attemptNum) {
-    const { backoff, delay = 1000, infinite, times = 3, maxDelay = 30000 } = retryOptions;
-    if (infinite || attemptNum < times) {
-        const delayTime = Math.min(delay * (backoff === 'constant' ? 1 : 2 ** attemptNum), maxDelay);
-        return delayTime;
-    }
-    return null;
-}
-function createRetryTimeout(retryOptions, attemptNum, fn) {
-    const delayTime = calculateRetryDelay(retryOptions, attemptNum);
-    if (delayTime) {
-        return setTimeout(fn, delayTime);
-    }
-}
-function runWithRetry(node, state, fn) {
-    const { retry, waitFor } = node.activationState;
-    const e = { cancel: false };
-    let value = undefined;
-    if (waitFor) {
-        value = whenReady(waitFor, () => {
-            node.activationState.waitFor = undefined;
-            return fn(e);
-        });
-    }
-    else {
-        value = fn(e);
-    }
-    if (isPromise(value) && retry) {
-        let timeoutRetry;
-        return new Promise((resolve) => {
-            const run = () => {
-                value
-                    .then((val) => {
-                    node.activationState.persistedRetry = false;
-                    resolve(val);
-                })
-                    .catch(() => {
-                    state.attemptNum++;
-                    if (timeoutRetry) {
-                        clearTimeout(timeoutRetry);
-                    }
-                    if (!e.cancel) {
-                        timeoutRetry = createRetryTimeout(retry, state.attemptNum, () => {
-                            value = fn(e);
-                            run();
-                        });
-                    }
-                })
-                    .finally(() => {
-                    node.activationState.persistedRetry = false;
-                });
-            };
-            run();
-        });
-    }
-    return value;
-}
-
-const noop = () => { };
 const ArrayModifiers = new Set([
     'copyWithin',
     'fill',
@@ -1734,8 +1666,14 @@ function peek(node) {
     if (lazy) {
         const lazyFn = node.lazyFn;
         delete node.lazy;
-        if (isFunction(node) || isFunction(lazyFn)) {
-            value = activateNodeFunction(node, lazyFn);
+        if (isFunction(lazyFn)) {
+            if (lazyFn.length === 1) {
+                // This is a lookup function, so return a record object
+                value = {};
+            }
+            else {
+                value = activateNodeFunction(node, lazyFn);
+            }
         }
     }
     if (lazy || node.needsExtract) {
@@ -1750,10 +1688,8 @@ function peek(node) {
 function reactivateNode(node, lazyFn) {
     var _a, _b;
     (_a = node.activatedObserveDispose) === null || _a === void 0 ? void 0 : _a.call(node);
-    node.activatedObserveDispose = undefined;
     (_b = node.linkedToNodeDispose) === null || _b === void 0 ? void 0 : _b.call(node);
-    node.linkedToNodeDispose = undefined;
-    node.linkedToNode = undefined;
+    node.activatedObserveDispose = node.linkedToNodeDispose = node.linkedToNode = undefined;
     node.lazyFn = lazyFn;
     node.lazy = true;
 }
@@ -1764,7 +1700,6 @@ function activateNodeFunction(node, lazyFn) {
     let wasPromise;
     let ignoreThisUpdate;
     const activateFn = lazyFn;
-    const doRetry = () => { var _a; return (_a = node.state) === null || _a === void 0 ? void 0 : _a.refreshNum.set((v) => v + 1); };
     let activatedValue;
     let disposes = [];
     let refreshFn;
@@ -1773,7 +1708,7 @@ function activateNodeFunction(node, lazyFn) {
         globalState.dirtyNodes.add(node);
     }
     node.activatedObserveDispose = observe(() => {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d;
         // const params = createNodeActivationParams(node);
         // Run the function at this node
         let value = activateFn();
@@ -1784,7 +1719,7 @@ function activateNodeFunction(node, lazyFn) {
         if (isFunction(value)) {
             value = value();
         }
-        const activated = value === null || value === void 0 ? void 0 : value[symbolSynced];
+        const activated = value === null || value === void 0 ? void 0 : value[symbolActivated];
         if (activated) {
             node.activationState = activated;
             value = undefined;
@@ -1795,29 +1730,25 @@ function activateNodeFunction(node, lazyFn) {
         // TODO: Is calling recursively bad? If so can it be fixed?
         if (!node.activated) {
             node.activated = true;
-            const isCached = !!((_a = node.activationState) === null || _a === void 0 ? void 0 : _a.cache);
-            wasPromise = wasPromise || !!isCached;
-            const activateNodeFn = wasPromise ? globalState.activateNode : activateNodeBase;
-            const { update: newUpdate, value: newValue } = activateNodeFn(node, doRetry, !!wasPromise, value);
+            let activateNodeFn = activateNodeBase;
+            // If this is a Synced then run it through persistence instead of base
+            if (activated === null || activated === void 0 ? void 0 : activated.synced) {
+                activateNodeFn = globalState.activateNodePersist;
+                wasPromise = true;
+            }
+            const { update: newUpdate, value: newValue } = activateNodeFn(node, value);
             update = newUpdate;
             value = newValue !== null && newValue !== void 0 ? newValue : activated === null || activated === void 0 ? void 0 : activated.initial;
         }
         else if (node.activationState) {
             if (!node.activationState.persistedRetry && !node.activationState.waitFor) {
                 const activated = node.activationState;
-                if ((_c = (_b = node.state) === null || _b === void 0 ? void 0 : _b.peek()) === null || _c === void 0 ? void 0 : _c.sync) {
+                if ((_b = (_a = node.state) === null || _a === void 0 ? void 0 : _a.peek()) === null || _b === void 0 ? void 0 : _b.sync) {
                     node.state.sync();
                     ignoreThisUpdate = true;
                 }
                 else {
-                    value =
-                        (_e = (_d = activated.get) === null || _d === void 0 ? void 0 : _d.call(activated, {
-                            updateLastSync: noop,
-                            setMode: noop,
-                            lastSync: undefined,
-                            value: undefined,
-                            refresh: doRetry,
-                        })) !== null && _e !== void 0 ? _e : activated.initial;
+                    value = (_d = (_c = activated.get) === null || _c === void 0 ? void 0 : _c.call(activated)) !== null && _d !== void 0 ? _d : activated.initial;
                 }
             }
             else {
@@ -1826,7 +1757,6 @@ function activateNodeFunction(node, lazyFn) {
         }
         // value is undefined if it's in a persisted retry
         wasPromise = wasPromise || isPromise(value);
-        get(getNode((_f = node.state) === null || _f === void 0 ? void 0 : _f.refreshNum));
         return value;
     }, (e) => {
         if (!ignoreThisUpdate) {
@@ -1882,29 +1812,16 @@ function activateNodeFunction(node, lazyFn) {
     }, { fromComputed: true });
     return activatedValue;
 }
-const activateNodeBase = (globalState.activateNode = function activateNodeBase(node, refresh, wasPromise, value) {
+function activateNodeBase(node, value) {
     if (!node.state) {
         node.state = createObservable({
             isLoaded: false,
         }, false, extractPromise, getProxy);
     }
     let isSetting = false;
-    let isSettingFromSubscribe = false;
-    let _mode = 'set';
     if (node.activationState) {
-        const { onSet, subscribe, get: getFn, initial } = node.activationState;
-        value = getFn
-            ? runWithRetry(node, { attemptNum: 0 }, () => {
-                return getFn({
-                    updateLastSync: noop,
-                    setMode: (mode) => (_mode = mode),
-                    lastSync: undefined,
-                    value: undefined,
-                    refresh,
-                });
-            })
-            : undefined;
-        // TODO Should this have lastSync and value somehow?
+        const { onSet, get: getFn, initial } = node.activationState;
+        value = getFn === null || getFn === void 0 ? void 0 : getFn();
         if (value == undefined || value === null) {
             value = initial;
         }
@@ -1940,49 +1857,22 @@ const activateNodeBase = (globalState.activateNode = function activateNodeBase(n
                             // set may get called multiple times before it loads so ignore any previous runs
                             return;
                         }
-                        const retryAttempts = { attemptNum: 0 };
-                        return runWithRetry(node, retryAttempts, (eventRetry) => {
-                            const cancelRetry = () => {
-                                eventRetry.cancel = true;
-                            };
-                            return new Promise((resolve, reject) => {
-                                isSetting = true;
-                                let isProm = false;
-                                batch(() => {
-                                    try {
-                                        const val = onSet({
-                                            value,
-                                            changes,
-                                            getPrevious,
-                                            node,
-                                            update,
-                                            refresh,
-                                            retryNum: retryAttempts.attemptNum,
-                                            cancelRetry,
-                                            fromSubscribe: isSettingFromSubscribe,
-                                        });
-                                        isProm = isPromise(val);
-                                        if (isProm) {
-                                            val.then(resolve).catch(reject);
-                                        }
-                                    }
-                                    catch (e) {
-                                        reject(e);
-                                    }
-                                }, () => {
-                                    if (!isProm) {
-                                        isSetting = false;
-                                        resolve();
-                                    }
-                                });
+                        isSetting = true;
+                        batch(() => {
+                            onSet({
+                                value,
+                                changes,
+                                getPrevious,
                             });
+                        }, () => {
+                            isSetting = false;
                         });
                     };
                     whenReady(node.state.isLoaded, run);
                 }
             };
             const onChangeImmediate = ({ value, changes }) => {
-                if (!isSetting || isSettingFromSubscribe) {
+                if (!isSetting) {
                     if (changes.length > 1 || !isFunction(changes[0].prevAtPath)) {
                         latestValue = value;
                         if (allChanges.length > 0) {
@@ -2000,68 +1890,32 @@ const activateNodeBase = (globalState.activateNode = function activateNodeBase(n
             onChange(node, onChangeImmediate, { immediate: true });
             onChange(node, runChanges);
         }
-        if (process.env.NODE_ENV === 'development' && node.activationState.cache) {
-            // TODO Better message
-            console.log('[legend-state] Using cache without setting up persistence first');
-        }
-        if (process.env.NODE_ENV === 'development' && node.activationState.retry) {
-            // TODO Better message
-            console.log('[legend-state] Using retry without setting up persistence first');
-        }
-        if (subscribe) {
-            const updateFromSubscribe = (params) => {
-                whenReady(node.state.isLoaded, () => {
-                    isSettingFromSubscribe = true;
-                    update(params);
-                    isSettingFromSubscribe = false;
-                });
-            };
-            subscribe({ node, update: updateFromSubscribe, refresh });
-        }
     }
-    const update = ({ value, mode }) => {
+    const update = ({ value }) => {
         // TODO: This isSetting might not be necessary? Tests still work if removing it.
         // Write tests that would break it if removed? I'd guess a combination of subscribe and
         if (!isSetting) {
             isSetting = true;
-            if (_mode === 'assign' || mode === 'assign') {
-                assign(node, value);
-            }
-            else if (_mode === 'merge' || mode === 'merge') {
-                mergeIntoObservable(getProxy(node), value);
-            }
-            else {
-                set(node, value);
-            }
+            set(node, value);
             isSetting = false;
         }
     };
     return { update, value };
-});
+}
 function setToObservable(node, value) {
     var _a;
     // If the computed is a proxy to another observable
     // link it to the target observable
     const linkedNode = getNode(value);
     if (linkedNode !== node && (linkedNode === null || linkedNode === void 0 ? void 0 : linkedNode.linkedToNode) !== node) {
-        const prevNode = node.linkedToNode;
         node.linkedToNode = linkedNode;
-        if (!linkedNode.linkedFromNodes) {
-            linkedNode.linkedFromNodes = new Set();
-        }
+        linkedNode.linkedFromNodes || (linkedNode.linkedFromNodes = new Set());
         linkedNode.linkedFromNodes.add(node);
-        peek(linkedNode);
         (_a = node.linkedToNodeDispose) === null || _a === void 0 ? void 0 : _a.call(node);
         node.linkedToNodeDispose = onChange(linkedNode, () => {
             value = peek(linkedNode);
             set(node, value);
         }, { initial: true }, new Set([node]));
-        // If the target observable is different then notify for the change
-        if (prevNode) {
-            const value = getNodeValue(linkedNode);
-            const prevValue = getNodeValue(prevNode);
-            notify(node, value, prevValue, 0);
-        }
     }
     return value;
 }
@@ -2133,7 +1987,7 @@ globalState.isLoadingRemote$ = observable(false);
 
 function computed(compute, set) {
     return observable(set
-        ? synced({
+        ? activated({
             get: compute,
             onSet: ({ value }) => set(value),
         })
@@ -2191,14 +2045,70 @@ function event() {
 }
 
 function proxy(get, set) {
-    return observable(synced({
-        lookup: (key) => set
-            ? synced({
-                get: () => get(key),
-                onSet: ({ value }) => set(key, value),
-            })
-            : get(key),
-    }));
+    return observable((key) => set
+        ? activated({
+            get: () => get(key),
+            onSet: ({ value }) => set(key, value),
+        })
+        : get(key));
+}
+
+function calculateRetryDelay(retryOptions, attemptNum) {
+    const { backoff, delay = 1000, infinite, times = 3, maxDelay = 30000 } = retryOptions;
+    if (infinite || attemptNum < times) {
+        const delayTime = Math.min(delay * (backoff === 'constant' ? 1 : 2 ** attemptNum), maxDelay);
+        return delayTime;
+    }
+    return null;
+}
+function createRetryTimeout(retryOptions, attemptNum, fn) {
+    const delayTime = calculateRetryDelay(retryOptions, attemptNum);
+    if (delayTime) {
+        return setTimeout(fn, delayTime);
+    }
+}
+function runWithRetry(node, state, fn) {
+    const { retry, waitFor } = node.activationState;
+    const e = { cancel: false };
+    let value = undefined;
+    if (waitFor) {
+        value = whenReady(waitFor, () => {
+            node.activationState.waitFor = undefined;
+            return fn(e);
+        });
+    }
+    else {
+        value = fn(e);
+    }
+    if (isPromise(value) && retry) {
+        let timeoutRetry;
+        return new Promise((resolve) => {
+            const run = () => {
+                value
+                    .then((val) => {
+                    node.activationState.persistedRetry = false;
+                    resolve(val);
+                })
+                    .catch(() => {
+                    state.attemptNum++;
+                    if (timeoutRetry) {
+                        clearTimeout(timeoutRetry);
+                    }
+                    if (!e.cancel) {
+                        timeoutRetry = createRetryTimeout(retry, state.attemptNum, () => {
+                            value = fn(e);
+                            run();
+                        });
+                    }
+                })
+                    .finally(() => {
+                    node.activationState.persistedRetry = false;
+                });
+            };
+            run();
+        });
+    }
+    return value;
 }
 
 const internal = {
@@ -2215,7 +2125,7 @@ const internal = {
     set,
     setAtPath,
     setNodeValue,
-    symbolSynced,
+    symbolActivated,
     symbolDelete,
 };
 
@@ -2264,7 +2174,6 @@ exports.setSilently = setSilently;
 exports.setupTracking = setupTracking;
 exports.symbolDelete = symbolDelete;
 exports.syncState = syncState;
-exports.synced = synced;
 exports.trackSelector = trackSelector;
 exports.tracking = tracking;
 exports.updateTracking = updateTracking;