pull carlos

Author: aquinojardim

dev-reactime/astParser.js

@@ -8,7 +8,10 @@ const JSXParser = acorn.Parser.extend(jsx());
 // Helper function to grab the getters/setters from `elementType`
 module.exports = elementType => {
   // Initialize empty object to store the setters and getter
+  console.log('entered ast parser');
+  //console.log('elementType: ', elementType);
   let ast = JSXParser.parse(elementType);
+  //console.log('ast:', ast);
   const hookState = {};
 
   while (Object.hasOwnProperty.call(ast, 'body')) {

dev-reactime/index.js

@@ -4,30 +4,34 @@
  */
 import 'core-js';
 import 'regenerator-runtime/runtime';
+import { exist } from 'acorn-jsx/xhtml';
 
 // * State snapshot object initialized here
 const snapShot = { 
   tree: null, 
   unfilteredTree: null 
 };
 
+
 const mode = {
   jumping: false,
   paused: false,
   locked: false,
 };
 
 const linkFiber = require('./linkFiber')(snapShot, mode);
+console.log('import timeJump in index.js:', JSON.parse(JSON.stringify(snapShot)));
 const timeJump = require('./timeJump')(snapShot, mode);
 
+
 function getRouteURL(node) {
   if (node.name === 'Router') {
     return node.state.location.pathname;
   }
   if (node.children && node.children.length >= 1) {
     const tempNode = node.children;
     for (let index = 0; index < tempNode.length; index += 1) {
-      return getRouteURL(tempNode[index]);
+      return getRouteURL(tempNode[index]); // Carlos: ???
     }
   }
 }
@@ -36,9 +40,12 @@ function getRouteURL(node) {
 window.addEventListener('message', ({ data: { action, payload } }) => {
   switch (action) {
     case 'jumpToSnap':
+      console.log('payload in jumpToSnap', payload);
       timeJump(payload); // * This sets state with given payload
       // Get the pathname from payload and add new entry to browser history
       // MORE: https://developer.mozilla.org/en-US/docs/Web/API/History/pushState
+
+      // try to modify workInProgress tree from here
       window.history.pushState('', '', getRouteURL(payload));
       break;
     case 'setLock':
@@ -52,5 +59,5 @@ window.addEventListener('message', ({ data: { action, payload } }) => {
   }
 });
 
-//module.exports = linkFiber;
+// module.exports = linkFiber;
 export default linkFiber;

dev-reactime/linkFiber.js

@@ -44,10 +44,15 @@
 /* eslint-disable no-use-before-define */
 /* eslint-disable no-param-reassign */
 
+<<<<<<< HEAD
 const { Tree, UnfilteredTreeNode } = require('./tree');
 const astParser = require('./astParser');
 const { saveState } = require('./masterState');
 // import * as reactWorkTags from './reactWorkTags';
+=======
+const Tree = require('./tree');
+const componentActionsRecord = require('./masterState');
+>>>>>>> 8e774670f36699322d70300c6382bcdcc7b349e0
 
 module.exports = (snap, mode) => {
   let fiberRoot = null;
@@ -64,109 +69,93 @@ module.exports = (snap, mode) => {
   ];
 
 
-  function sendSnapshot() {
+  async function sendSnapshot() {
     // Don't send messages while jumping or while paused
-    // DEV: So that when we are jumping to an old snapshot it
     if (mode.jumping || mode.paused) return;
-    const payload = snap.tree.getCopy();
-    window.postMessage({
-      action: 'recordSnap',
-      payload,
-    });
-  }
-
-  function changeSetState(component) {
-    if (component.setState.linkFiberChanged) return;
-
-    // Persist the old setState and bind to component so we can continue to setState({})
-    const oldSetState = component.setState.bind(component);
-
-    component.setState = (state, callback = () => {}) => {
-      // Don't do anything if state is locked UNLESS we are currently jumping through time
-      if (mode.locked && !mode.jumping) return;
-      // Continue normal setState functionality, with middleware in callback
-      oldSetState(state, () => {
-        updateSnapShotTree();
-        sendSnapshot();
-        callback.bind(component)();
+    // console.log('PAYLOAD: before cleaning', snap.tree);
+    const payload = snap.tree.cleanTreeCopy();// snap.tree.getCopy();
+    // console.log('PAYLOAD: after cleaning', payload);
+    try {
+      await window.postMessage({
+        action: 'recordSnap',
+        payload,
       });
-    };
-    // Set a custom property to ensure we don't change this method again
-    component.setState.linkFiberChanged = true;
-  }
-
-  function changeUseState(component) {
-    if (component.queue.dispatch.linkFiberChanged) return;
-
-    // Persist the old dispatch and bind to component so we can continue to dispatch()
-    const oldDispatch = component.queue.dispatch.bind(component.queue);
-
-    component.queue.dispatch = (fiber, queue, action) => {
-      if (mode.locked && !mode.jumping) return;
-      oldDispatch(fiber, queue, action);
-      // * Uncomment setTimeout to prevent snapshot lag-effect
-      // * (i.e. getting the prior snapshot on each state change)
-      // setTimeout(() => {
-      updateSnapShotTree();
-      sendSnapshot();
-      // }, 100);
-    };
-    // Set a custom property to ensure we don't change this method again
-    component.queue.dispatch.linkFiberChanged = true;
+    } catch (e) {
+      console.log('failed to send postMessage:', e);
+    }
   }
 
-  // TODO: WE NEED TO CLEAN IT UP A BIT
+  // Carlos: Injects instrumentation to update our state tree every time
+  // a hooks component changes state
   function traverseHooks(memoizedState) {
-    // Declare variables and assigned to 0th index and an empty object, respectively
-    const memoized = {};
-    let index = 0;
-    astHooks = Object.values(astHooks);
-    // While memoizedState is truthy, save the value to the object
+    const hooksComponents = [];
     while (memoizedState && memoizedState.queue) {
-      // // prevents useEffect from crashing on load
+      // Carlos: these two are legacy comments, we should look into them later
+      // prevents useEffect from crashing on load
       // if (memoizedState.next.queue === null) { // prevents double pushing snapshot updates
-      changeUseState(memoizedState);
-      // }
-      // memoized[astHooks[index]] = memoizedState.memoizedState;
-      memoized[astHooks[index]] = memoizedState.memoizedState;
-      // Reassign memoizedState to its next value
-      memoizedState = memoizedState.next;
-      // See astParser.js for explanation of this increment
-      index += 2;
+      if (memoizedState.memoizedState) {
+        console.log('memoizedState in traverseHooks is:', memoizedState);
+        hooksComponents.push({
+          component: memoizedState.queue,
+          state: memoizedState.memoizedState,
+        });
+      }
+      // console.log('GOT STATE', memoizedState.memoizedState);
+      memoizedState = memoizedState.next !== memoizedState
+        ? memoizedState.next : null;
     }
-    return memoized;
+    return hooksComponents;
   }
 
-  
-  function createTree(curFiber, parentNode) {
-    // on call from updateSnapShot, no parentNode provided, so create a root node
-    if(! parentNode) parentNode = new Tree('root');
-    
-    // Base case: parentNode's child or sibling pointed to null
-    if (!curFiber) return parentNode;
-    
-    let newChildNode = null;
-
-    // If stateful, add to parentNode's children array, then inject new setState into fiber node
-    if (curFiber.stateNode && curFiber.stateNode.state) {
-      newChildNode = parentNode.appendChild(curFiber.stateNode);
-      changeSetState(curFiber.stateNode);
-
-      // newChildNode.isStateful = true;
-      newChildNode.tagLabel = reactWorkTags[curFiber.tag];
-      newChildNode.actualDuration = curFiber.actualDuration;
-      // newChildNode.actualStartTime = curFiber.actualStartTime;
-      // newChildNode.selfBaseDuration = curFiber.selfBaseDuration;
-      // newChildNode.treeBaseDuration = curFiber.treeBaseDuration;
+  // Carlos: This runs after EVERY Fiber commit. It creates a new snapshot,
+  //
+  function createTree(currentFiber, tree = new Tree('root')) {
+    // Base case: child or sibling pointed to null
+    if (!currentFiber) return tree;
+
+    // These have the newest state. We update state and then
+    // called updateSnapshotTree()
+    const {
+      sibling,
+      stateNode,
+      child,
+      memoizedState,
+      elementType,
+      tag,
+    } = currentFiber;
+
+    let index;
+    // Check if node is a stateful component
+    if (stateNode && stateNode.state && (tag === 0 || tag === 1)) {
+      // Save component's state and setState() function to our record for future
+      // time-travel state changing. Add record index to snapshot so we can retrieve.
+      index = componentActionsRecord.saveNew(stateNode.state, stateNode);
+      tree.appendChild(stateNode.state, elementType.name, index); // Add component to tree
+    } else {
+      // grab stateless components here
     }
 
-    // Recurse to sibling; siblings that have state should be added to our parentNode
-    createTree(curFiber.sibling, parentNode);  
+    // Check if node is a hooks function
+    if (memoizedState && (tag === 0 || tag === 1 || tag === 10)) {
+      if (memoizedState.queue) {
+        const hooksComponents = traverseHooks(memoizedState);
+        hooksComponents.forEach(c => {
+          if (elementType.name) {
+            index = componentActionsRecord.saveNew(c.state, c.component);
+            tree.appendChild(c.state, elementType.name ? elementType.name : 'nameless', index);
+          }
+        });
+      }
+    }
 
-    // Recurse to child; If this fiber was stateful, then we added a newChildNode here, and we want
-    // to attach further children to that. If this fiber wasn't stateful, we want to attach any 
-    // children to our existing parentNode.
-    createTree(curFiber.child, newChildNode || parentNode);
+    // Recurse on siblings
+    createTree(sibling, tree);
+    // Recurse on children
+    if (tree.children.length > 0) {
+      createTree(child, tree.children[0]);
+    } else {
+      createTree(child, tree);
+    }
 
     return parentNode;
   }
@@ -204,26 +193,31 @@ module.exports = (snap, mode) => {
 
 
   // ! BUG: skips 1st hook click
-  async function updateSnapShotTree() {
-    let current;
+  function updateSnapShotTree() {
+    /* let current;
     // If concurrent mode, grab current.child
     if (concurrent) {
       // we need a way to wait for current child to populate
       const promise = new Promise((resolve, reject) => {
         setTimeout(() => resolve(fiberRoot.current.child), 400);
       });
-
       current = await promise;
-
       current = fiberRoot.current.child;
     } else {
       current = fiberRoot.current;
-    }
+    } */
+    const { current } = fiberRoot; // Carlos: get rid of concurrent mode for now
 
+<<<<<<< HEAD
     snap.tree = createTree(current);
     console.log("updateSnapShotTree -> snap.tree", snap.tree)
     // snap.unfilteredTree = createUnfilteredTree(current);
     // console.log("updateSnapShotTree -> snap.unfilteredTree", snap.unfilteredTree)
+=======
+    // console.log('FIBER COMMITTED, new fiber is:', util.inspect(current, false, 4));
+    // fs.appendFile('fiberlog.txt', util.inspect(current, false, 10));
+    snap.tree = createTree(current); // Carlos: pass new hooks state here?
+>>>>>>> 8e774670f36699322d70300c6382bcdcc7b349e0
   }
 
   return async container => {
@@ -238,15 +232,30 @@ module.exports = (snap, mode) => {
       } = container;
       // Only assign internal root if it actually exists
       fiberRoot = _internalRoot || _reactRootContainer;
-      console.log('linkFiber.js, fiberRoot:', fiberRoot);
+      // console.log('_reactRootContainer is:', _reactRootContainer);
+      // console.log('linkFiber.js, fiberRoot:', fiberRoot);
     }
-
-    await updateSnapShotTree();
+    const devTools = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    const reactInstance = devTools ? devTools.renderers.get(1) : null;
+    const overrideHookState = reactInstance ? reactInstance.overrideHookState : null;
+    console.log('DEVTOOLS:', devTools);
+    console.log('roots:', reactInstance.getCurrentFiber())
+
+    if (reactInstance && reactInstance.version) {
+      devTools.onCommitFiberRoot = (function (original) {
+        return function (...args) {
+          fiberRoot = args[1];
+          updateSnapShotTree();
+          sendSnapshot();
+          return original(...args);
+        };
+      }(devTools.onCommitFiberRoot));
+    }
+    updateSnapShotTree();
     // Send the initial snapshot once the content script has started up
     // This message is sent from contentScript.js in chrome extension bundles
     window.addEventListener('message', ({ data: { action } }) => {
       if (action === 'contentScriptStarted') {
-        console.log('linkFiber.js received contentScriptStarted message, sending snapshot');
         sendSnapshot();
       }
     });

dev-reactime/masterState.js

@@ -1,8 +1,25 @@
+/* eslint-disable no-plusplus */
 /* eslint-disable guard-for-in */
 /* eslint-disable no-restricted-syntax */
-// Export two functions that either saves the AST state object into an array
-// or returns the array for use
-const masterState = [];
+
+const componentActionsRecord = {};
+let index = 0;
+
+module.exports = {
+  saveNew: (state, component) => {
+    componentActionsRecord[index] = { state, component };
+    index++;
+    return index - 1;
+  },
+  getRecordByIndex: inputIndex => componentActionsRecord[inputIndex],
+  getComponentByIndex: inputIndex => (componentActionsRecord[inputIndex]
+    ? componentActionsRecord[inputIndex].component
+    : undefined),
+};
+
+
+/* const masterState = [];
+const hooksComponentsActions = {};
 
 module.exports = {
   saveState: state => {
@@ -12,4 +29,10 @@ module.exports = {
     return masterState;
   },
   returnState: () => masterState,
+  saveHooksComponent: stateAndAction => {
+    for (const elementName in stateAndAction) {
+      hooksComponentsActions[elementName] = stateAndAction[elementName];
+    }
+  },
 };
+ */