roxxie-proxy-u-prod 0.1.0

package/source/packages/cdp/src/domains/DOM.ts

@@ -0,0 +1,487 @@
+import connector from '../lib/connector'
+import * as nodeManager from '../lib/nodeManager'
+import { getNode, getNodeId } from '../lib/nodeManager'
+import * as objManager from '../lib/objManager'
+import mutationObserver from '../lib/mutationObserver'
+import $ from 'licia/$'
+import isNull from 'licia/isNull'
+import isEmpty from 'licia/isEmpty'
+import html from 'licia/html'
+import map from 'licia/map'
+import unique from 'licia/unique'
+import types from 'licia/types'
+import contain from 'licia/contain'
+import lowerCase from 'licia/lowerCase'
+import each from 'licia/each'
+import toArr from 'licia/toArr'
+import xpath from 'licia/xpath'
+import concat from 'licia/concat'
+import { setGlobal } from '../lib/evaluate'
+import { createId } from '../lib/util'
+import { getObj } from '../lib/objManager'
+import Protocol from 'devtools-protocol'
+import DOM = Protocol.DOM
+
+export function collectClassNamesFromSubtree(
+  params: DOM.CollectClassNamesFromSubtreeRequest
+): DOM.CollectClassNamesFromSubtreeResponse {
+  const node = getNode(params.nodeId)
+
+  const classNames: string[] = []
+
+  traverseNode(node, (node: any) => {
+    if (node.nodeType !== 1) return
+    const className = node.getAttribute('class')
+    if (className) {
+      const names = className.split(/\s+/)
+      for (const name of names) classNames.push(name)
+    }
+  })
+
+  return {
+    classNames: unique(classNames),
+  }
+}
+
+export function copyTo(params: DOM.CopyToRequest): DOM.CopyToResponse {
+  const { nodeId, targetNodeId } = params
+
+  const node = getNode(nodeId)
+  const targetNode = getNode(targetNodeId)
+
+  const cloneNode = node.cloneNode(true)
+  targetNode.appendChild(cloneNode)
+
+  return {
+    nodeId: getNodeId(cloneNode),
+  }
+}
+
+let isEnable = false
+
+export function enable() {
+  isEnable = true
+
+  mutationObserver.disconnect()
+  mutationObserver.observe(document.documentElement)
+  nodeManager.clear()
+}
+
+function hookAttachShadow() {
+  const origAttachShadow = Element.prototype.attachShadow
+  if (origAttachShadow) {
+    Element.prototype.attachShadow = function (init) {
+      const shadowRoot = origAttachShadow.apply(this, [init])
+      if (!nodeManager.isValidNode(this)) {
+        return shadowRoot
+      }
+
+      ;(this as any).chobitsuShadowRoot = shadowRoot
+      if (isEnable) {
+        mutationObserver.observe(shadowRoot)
+        const hostId = getNodeId(this)
+        if (hostId) {
+          connector.trigger('DOM.shadowRootPushed', {
+            hostId,
+            root: nodeManager.wrap(shadowRoot, { depth: 1 }),
+          })
+        }
+      }
+      return shadowRoot
+    }
+  }
+}
+
+hookAttachShadow()
+
+
+export function describeNode(params: DOM.DescribeNodeRequest): DOM.DescribeNodeResponse {
+  let domnode = getObj(params.objectId!);
+
+  let node = nodeManager.wrap(domnode);
+  console.error(node);
+  console.error(getNode(node.nodeId));
+
+  return {
+    node,
+  }
+}
+
+export function getDocument() {
+  return {
+    root: nodeManager.wrap(document, {
+      depth: 2,
+    }),
+  }
+}
+
+export function getOuterHTML(
+  params: DOM.GetOuterHTMLRequest
+): DOM.GetOuterHTMLResponse {
+  let outerHTML = ''
+
+  if (params.nodeId) {
+    const node = getNode(params.nodeId)
+    outerHTML = node.outerHTML
+  }
+
+  return {
+    outerHTML,
+  }
+}
+
+export function moveTo(params: DOM.MoveToRequest): DOM.MoveToResponse {
+  const { nodeId, targetNodeId } = params
+
+  const node = getNode(nodeId)
+  const targetNode = getNode(targetNodeId)
+
+  targetNode.appendChild(node)
+
+  return {
+    nodeId: getNodeId(node),
+  }
+}
+
+const searchResults = new Map()
+
+export function performSearch(
+  params: DOM.PerformSearchRequest
+): DOM.PerformSearchResponse {
+  const query = lowerCase(params.query)
+  let result: any[] = []
+
+  try {
+    result = concat(result, toArr(document.querySelectorAll(query)))
+  } catch (e) {
+    /* tslint:disable-next-line */
+  }
+  try {
+    result = concat(result, xpath(query))
+  } catch (e) {
+    /* tslint:disable-next-line */
+  }
+  traverseNode(document, (node: any) => {
+    const { nodeType } = node
+    if (nodeType === 1) {
+      const localName = node.localName
+      if (
+        contain(`<${localName} `, query) ||
+        contain(`</${localName}>`, query)
+      ) {
+        result.push(node)
+        return
+      }
+
+      const attributes: string[] = []
+      each(node.attributes, ({ name, value }) => attributes.push(name, value))
+      for (let i = 0, len = attributes.length; i < len; i++) {
+        if (contain(lowerCase(attributes[i]), query)) {
+          result.push(node)
+          break
+        }
+      }
+    } else if (nodeType === 3) {
+      if (contain(lowerCase(node.nodeValue), query)) {
+        result.push(node)
+      }
+    }
+  })
+
+  const searchId = createId()
+  searchResults.set(searchId, result)
+
+  return {
+    searchId,
+    resultCount: result.length,
+  }
+}
+
+export function getSearchResults(
+  params: DOM.GetSearchResultsRequest
+): DOM.GetSearchResultsResponse {
+  const { searchId, fromIndex, toIndex } = params
+
+  const searchResult = searchResults.get(searchId)
+  const result = searchResult.slice(fromIndex, toIndex)
+  const nodeIds = map(result, (node: any) => {
+    const nodeId = getNodeId(node)
+
+    if (!nodeId) {
+      return pushNodesToFrontend(node)
+    }
+
+    return nodeId
+  })
+
+  return {
+    nodeIds,
+  }
+}
+
+// Make sure all parent nodes has been retrieved.
+export function pushNodesToFrontend(node: any) {
+  const nodes = [node]
+  let parentNode = node.parentNode
+  while (parentNode) {
+    nodes.push(parentNode)
+    const nodeId = getNodeId(parentNode)
+    if (nodeId) {
+      break
+    } else {
+      parentNode = parentNode.parentNode
+    }
+  }
+  while (nodes.length) {
+    const node = nodes.pop()
+    const nodeId = getNodeId(node)
+    connector.trigger('DOM.setChildNodes', {
+      parentId: nodeId,
+      nodes: nodeManager.getChildNodes(node, 1),
+    })
+  }
+
+  return getNodeId(node)
+}
+
+export function discardSearchResults(params: DOM.DiscardSearchResultsRequest) {
+  searchResults.delete(params.searchId)
+}
+
+export function pushNodesByBackendIdsToFrontend(
+  params: DOM.PushNodesByBackendIdsToFrontendRequest
+): DOM.PushNodesByBackendIdsToFrontendResponse {
+  return {
+    nodeIds: params.backendNodeIds,
+  }
+}
+
+export function removeNode(params: DOM.RemoveNodeRequest) {
+  const node = getNode(params.nodeId)
+
+  $(node).remove()
+}
+
+export function requestChildNodes(params: DOM.RequestChildNodesRequest) {
+  const { nodeId, depth = 1 } = params
+  const node = getNode(nodeId)
+
+  connector.trigger('DOM.setChildNodes', {
+    parentId: nodeId,
+    nodes: nodeManager.getChildNodes(node, depth),
+  })
+}
+
+export function scrollIntoViewIfNeeded(
+  params: DOM.ScrollIntoViewIfNeededRequest
+){
+  let node = getObj(params.objectId!);
+  node.scrollIntoViewIfNeeded();
+}
+export function getContentQuads(
+  params: DOM.GetContentQuadsRequest
+): DOM.GetContentQuadsResponse {
+  const node = getObj(params.objectId!);
+  const rect = node.getBoundingClientRect()
+  const { x, y, width, height } = rect
+
+  const quads = [
+    x,
+    y,
+    x + width,
+    y,
+    x + width,
+    y + height,
+    x,
+    y + height,
+  ]
+
+  return {
+    quads: [quads],
+  }
+}
+
+export function requestNode(
+  params: DOM.RequestNodeRequest
+): DOM.RequestNodeResponse {
+  const node = objManager.getObj(params.objectId)
+
+  return {
+    nodeId: getNodeId(node),
+  }
+}
+
+export function resolveNode(
+  params: DOM.ResolveNodeRequest
+): DOM.ResolveNodeResponse {
+  const node = getNode(params.nodeId || params.backendNodeId as number)
+
+  return {
+    object: objManager.wrap(node),
+  }
+}
+
+export function setAttributesAsText(params: DOM.SetAttributesAsTextRequest) {
+  const { name, text, nodeId } = params
+
+  const node = getNode(nodeId)
+  if (name) {
+    node.removeAttribute(name)
+  }
+  $(node).attr(parseAttributes(text))
+}
+
+export function setAttributeValue(params: DOM.SetAttributeValueRequest) {
+  const { nodeId, name, value } = params
+  const node = getNode(nodeId)
+  node.setAttribute(name, value)
+}
+
+const history: any[] = []
+
+export function setInspectedNode(params: DOM.SetInspectedNodeRequest) {
+  const node = getNode(params.nodeId)
+  history.unshift(node)
+  if (history.length > 5) history.pop()
+  for (let i = 0; i < 5; i++) {
+    setGlobal(`$${i}`, history[i])
+  }
+}
+
+export function setNodeValue(params: DOM.SetNodeValueRequest) {
+  const { nodeId, value } = params
+  const node = getNode(nodeId)
+  node.nodeValue = value
+}
+
+export function setOuterHTML(params: DOM.SetOuterHTMLRequest) {
+  const { nodeId, outerHTML } = params
+
+  const node = getNode(nodeId)
+  node.outerHTML = outerHTML
+}
+
+export function getDOMNodeId(params: any) {
+  const { node } = params
+  return {
+    nodeId: nodeManager.getOrCreateNodeId(node),
+  }
+}
+
+export function getDOMNode(params: any) {
+  const { nodeId } = params
+
+  return {
+    node: getNode(nodeId),
+  }
+}
+
+export function getTopLayerElements(): DOM.GetTopLayerElementsResponse {
+  return {
+    nodeIds: [],
+  }
+}
+
+export function getNodesForSubtreeByStyle(): DOM.GetNodesForSubtreeByStyleResponse {
+  return {
+    nodeIds: [],
+  }
+}
+
+function parseAttributes(str: string) {
+  str = `<div ${str}></div>`
+
+  return html.parse(str)[0].attrs
+}
+
+function traverseNode(node: any, cb: types.AnyFn) {
+  const childNodes = nodeManager.filterNodes(node.childNodes)
+  for (let i = 0, len = childNodes.length; i < len; i++) {
+    const child = childNodes[i]
+    cb(child)
+    traverseNode(child, cb)
+  }
+}
+
+mutationObserver.on('attributes', (target: any, name: string) => {
+  const nodeId = getNodeId(target)
+  if (!nodeId) return
+
+  const value = target.getAttribute(name)
+
+  if (isNull(value)) {
+    connector.trigger('DOM.attributeRemoved', {
+      nodeId,
+      name,
+    })
+  } else {
+    connector.trigger('DOM.attributeModified', {
+      nodeId,
+      name,
+      value,
+    })
+  }
+})
+
+mutationObserver.on(
+  'childList',
+  (target: Node, addedNodes: NodeList, removedNodes: NodeList) => {
+    const parentNodeId = getNodeId(target)
+    if (!parentNodeId) return
+
+    addedNodes = nodeManager.filterNodes(addedNodes)
+    removedNodes = nodeManager.filterNodes(removedNodes)
+
+    function childNodeCountUpdated() {
+      connector.trigger('DOM.childNodeCountUpdated', {
+        childNodeCount: nodeManager.wrap(target, {
+          depth: 0,
+        }).childNodeCount,
+        nodeId: parentNodeId,
+      })
+    }
+
+    if (!isEmpty(addedNodes)) {
+      childNodeCountUpdated()
+      for (let i = 0, len = addedNodes.length; i < len; i++) {
+        const node = addedNodes[i]
+        const previousNode = nodeManager.getPreviousNode(node)
+        const previousNodeId = previousNode ? getNodeId(previousNode) : 0
+        const params: any = {
+          node: nodeManager.wrap(node, {
+            depth: 0,
+          }),
+          parentNodeId,
+          previousNodeId,
+        }
+
+        connector.trigger('DOM.childNodeInserted', params)
+      }
+    }
+
+    if (!isEmpty(removedNodes)) {
+      for (let i = 0, len = removedNodes.length; i < len; i++) {
+        const node = removedNodes[i]
+        const nodeId = getNodeId(node)
+        if (!nodeId) {
+          childNodeCountUpdated()
+          break
+        }
+        connector.trigger('DOM.childNodeRemoved', {
+          nodeId: getNodeId(node),
+          parentNodeId,
+        })
+      }
+    }
+  }
+)
+
+mutationObserver.on('characterData', (target: Node) => {
+  const nodeId = getNodeId(target)
+  if (!nodeId) return
+
+  connector.trigger('DOM.characterDataModified', {
+    characterData: target.nodeValue,
+    nodeId,
+  })
+})

package/source/packages/cdp/src/domains/DOMDebugger.ts

@@ -0,0 +1,109 @@
+import safeGet from 'licia/safeGet'
+import isEl from 'licia/isEl'
+import isFn from 'licia/isFn'
+import isBool from 'licia/isBool'
+import keys from 'licia/keys'
+import each from 'licia/each'
+import defaults from 'licia/defaults'
+import isObj from 'licia/isObj'
+import * as objManager from '../lib/objManager'
+import Protocol from 'devtools-protocol'
+import DOMDebugger = Protocol.DOMDebugger
+
+export function getEventListeners(
+  params: DOMDebugger.GetEventListenersRequest
+): DOMDebugger.GetEventListenersResponse {
+  const obj = objManager.getObj(params.objectId)
+
+  const events = obj.chobitsuEvents || []
+  const listeners: any[] = []
+
+  each(events, (events: any[], type) => {
+    each(events, event => {
+      listeners.push({
+        type,
+        useCapture: event.useCapture,
+        handler: objManager.wrap(event.listener),
+        passive: event.passive,
+        once: event.once,
+        scriptId: '1',
+        columnNumber: 0,
+        lineNumber: 0,
+      })
+    })
+  })
+
+  return {
+    listeners,
+  }
+}
+
+const getWinEventProto = () => {
+  return safeGet(window, 'EventTarget.prototype') || window.Node.prototype
+}
+
+const winEventProto = getWinEventProto()
+
+const origAddEvent = winEventProto.addEventListener
+const origRmEvent = winEventProto.removeEventListener
+
+winEventProto.addEventListener = function (
+  type: string,
+  listener: any,
+  options: any
+) {
+  addEvent(this, type, listener, options)
+  origAddEvent.apply(this, arguments)
+}
+
+winEventProto.removeEventListener = function (type: string, listener: any) {
+  rmEvent(this, type, listener)
+  origRmEvent.apply(this, arguments)
+}
+
+function addEvent(el: any, type: string, listener: any, options: any = false) {
+  if (!isEl(el) || !isFn(listener)) return
+
+  if (isBool(options)) {
+    options = {
+      capture: options,
+    }
+  } else if (!isObj(options)) {
+    options = {}
+  }
+  defaults(options, {
+    capture: false,
+    passive: false,
+    once: false,
+  })
+
+  const events = ((el as any).chobitsuEvents = (el as any).chobitsuEvents || {})
+
+  events[type] = events[type] || []
+  events[type].push({
+    listener,
+    useCapture: options.capture,
+    passive: options.passive,
+    once: options.once,
+  })
+}
+
+function rmEvent(el: any, type: string, listener: any) {
+  if (!isEl(el) || !isFn(listener)) return
+
+  const events = (el as any).chobitsuEvents
+
+  if (!(events && events[type])) return
+
+  const listeners = events[type]
+
+  for (let i = 0, len = listeners.length; i < len; i++) {
+    if (listeners[i].listener === listener) {
+      listeners.splice(i, 1)
+      break
+    }
+  }
+
+  if (listeners.length === 0) delete events[type]
+  if (keys(events).length === 0) delete (el as any).chobitsuEvents
+}

package/source/packages/cdp/src/domains/DOMStorage.ts

@@ -0,0 +1,122 @@
+import safeStorage from 'licia/safeStorage'
+import each from 'licia/each'
+import isStr from 'licia/isStr'
+import once from 'licia/once'
+import jsonClone from 'licia/jsonClone'
+import connector from '../lib/connector'
+import detectBrowser from 'licia/detectBrowser'
+import Protocol from 'devtools-protocol'
+import DOMStorage = Protocol.DOMStorage
+
+const localStore = safeStorage('local')
+const sessionStore = safeStorage('session')
+const browser = detectBrowser()
+
+export function clear(params: DOMStorage.ClearRequest) {
+  const store = getStore(params.storageId)
+
+  store.clear()
+}
+
+export function getDOMStorageItems(
+  params: DOMStorage.GetDOMStorageItemsRequest
+): DOMStorage.GetDOMStorageItemsResponse {
+  const store = getStore(params.storageId)
+
+  const entries: string[][] = []
+
+  each(jsonClone(store), (val, key: string) => {
+    if (!isStr(val)) return
+
+    entries.push([key, val])
+  })
+
+  return {
+    entries,
+  }
+}
+
+export function removeDOMStorageItem(
+  params: DOMStorage.RemoveDOMStorageItemRequest
+) {
+  const { key, storageId } = params
+
+  const store = getStore(storageId)
+
+  store.removeItem(key)
+}
+
+export function setDOMStorageItem(params: DOMStorage.SetDOMStorageItemRequest) {
+  const { key, value, storageId } = params
+
+  const store = getStore(storageId)
+
+  store.setItem(key, value)
+}
+
+export const enable = once(function () {
+  // IE localStorage is incorrectly implemented.
+  if (browser.name === 'ie') {
+    return
+  }
+  each(['local', 'session'], type => {
+    const store = type === 'local' ? localStore : sessionStore
+    const storageId = getStorageId(type)
+
+    const originSetItem = store.setItem.bind(store)
+    store.setItem = function (key: string, value: string) {
+      if (!isStr(key) || !isStr(value)) return
+
+      const oldValue = store.getItem(key)
+      originSetItem(key, value)
+      if (oldValue) {
+        connector.trigger('DOMStorage.domStorageItemUpdated', {
+          key,
+          newValue: value,
+          oldValue,
+          storageId,
+        })
+      } else {
+        connector.trigger('DOMStorage.domStorageItemAdded', {
+          key,
+          newValue: value,
+          storageId,
+        })
+      }
+    }
+
+    const originRemoveItem = store.removeItem.bind(store)
+    store.removeItem = function (key: string) {
+      if (!isStr(key)) return
+      const oldValue = store.getItem(key)
+      if (oldValue) {
+        originRemoveItem(key)
+        connector.trigger('DOMStorage.domStorageItemRemoved', {
+          key,
+          storageId,
+        })
+      }
+    }
+
+    const originClear = store.clear.bind(store)
+    store.clear = function () {
+      originClear()
+      connector.trigger('DOMStorage.domStorageItemsCleared', {
+        storageId,
+      })
+    }
+  })
+})
+
+function getStorageId(type: string) {
+  return {
+    securityOrigin: location.origin,
+    isLocalStorage: type === 'local',
+  }
+}
+
+function getStore(storageId: any) {
+  const { isLocalStorage } = storageId
+
+  return isLocalStorage ? localStore : sessionStore
+}