fix(core): update attachedstate to nodepointer

feat: getComputedVisibility(node|element)

Author: blakebyrnes

client/lib/Agent.ts

@@ -15,10 +15,11 @@ import IWaitForElementOptions from '@secret-agent/interfaces/IWaitForElementOpti
 import { ILocationTrigger } from '@secret-agent/interfaces/Location';
 import Request from 'awaited-dom/impl/official-klasses/Request';
 import IWaitForOptions from '@secret-agent/interfaces/IWaitForOptions';
-import { IElementIsolate } from 'awaited-dom/base/interfaces/isolate';
+import { IElementIsolate, INodeIsolate } from 'awaited-dom/base/interfaces/isolate';
 import CSSStyleDeclaration from 'awaited-dom/impl/official-klasses/CSSStyleDeclaration';
 import IAgentMeta from '@secret-agent/interfaces/IAgentMeta';
 import IScreenshotOptions from '@secret-agent/interfaces/IScreenshotOptions';
+import { INodeVisibility } from '@secret-agent/interfaces/INodeVisibility';
 import WebsocketResource from './WebsocketResource';
 import IWaitForResourceFilter from '../interfaces/IWaitForResourceFilter';
 import Resource from './Resource';
@@ -277,12 +278,17 @@ export default class Agent extends AwaitedEventTarget<{ close: void }> {
     return this.activeTab.getComputedStyle(element, pseudoElement);
   }
 
+  public getComputedVisibility(node: INodeIsolate): Promise<INodeVisibility> {
+    return this.activeTab.getComputedVisibility(node);
+  }
+
   public getJsValue<T>(path: string): Promise<T> {
     return this.activeTab.getJsValue<T>(path);
   }
 
-  public isElementVisible(element: IElementIsolate): Promise<boolean> {
-    return this.activeTab.isElementVisible(element);
+  // @deprecated 2021-04-30: Replaced with getComputedVisibility
+  public async isElementVisible(element: IElementIsolate): Promise<boolean> {
+    return await this.getComputedVisibility(element as any).then(x => x.isVisible);
   }
 
   public takeScreenshot(options?: IScreenshotOptions): Promise<Buffer> {

client/lib/CoreFrameEnvironment.ts

@@ -6,10 +6,11 @@ import { ICookie } from '@secret-agent/interfaces/ICookie';
 import IWaitForElementOptions from '@secret-agent/interfaces/IWaitForElementOptions';
 import IExecJsPathResult from '@secret-agent/interfaces/IExecJsPathResult';
 import { IRequestInit } from 'awaited-dom/base/interfaces/official';
-import IAttachedState from 'awaited-dom/base/IAttachedState';
+import INodePointer from 'awaited-dom/base/INodePointer';
 import ISetCookieOptions from '@secret-agent/interfaces/ISetCookieOptions';
 import IWaitForOptions from '@secret-agent/interfaces/IWaitForOptions';
 import IFrameMeta from '@secret-agent/interfaces/IFrameMeta';
+import { INodeVisibility } from '@secret-agent/interfaces/INodeVisibility';
 import CoreCommandQueue from './CoreCommandQueue';
 
 export default class CoreFrameEnvironment {
@@ -48,11 +49,11 @@ export default class CoreFrameEnvironment {
     return await this.commandQueue.run('FrameEnvironment.getJsValue', expression);
   }
 
-  public async fetch(request: string | number, init?: IRequestInit): Promise<IAttachedState> {
+  public async fetch(request: string | number, init?: IRequestInit): Promise<INodePointer> {
     return await this.commandQueue.run('FrameEnvironment.fetch', request, init);
   }
 
-  public async createRequest(input: string | number, init?: IRequestInit): Promise<IAttachedState> {
+  public async createRequest(input: string | number, init?: IRequestInit): Promise<INodePointer> {
     return await this.commandQueue.run('FrameEnvironment.createRequest', input, init);
   }
 
@@ -80,8 +81,8 @@ export default class CoreFrameEnvironment {
     return await this.commandQueue.run('FrameEnvironment.removeCookie', name);
   }
 
-  public async isElementVisible(jsPath: IJsPath): Promise<boolean> {
-    return await this.commandQueue.run('FrameEnvironment.isElementVisible', jsPath);
+  public async getComputedVisibility(jsPath: IJsPath): Promise<INodeVisibility> {
+    return await this.commandQueue.run('FrameEnvironment.getComputedVisibility', jsPath);
   }
 
   public async waitForElement(jsPath: IJsPath, opts: IWaitForElementOptions): Promise<void> {

client/lib/FrameEnvironment.ts

@@ -17,7 +17,8 @@ import { ILocationTrigger, LocationStatus } from '@secret-agent/interfaces/Locat
 import IWaitForElementOptions from '@secret-agent/interfaces/IWaitForElementOptions';
 import Response from 'awaited-dom/impl/official-klasses/Response';
 import IWaitForOptions from '@secret-agent/interfaces/IWaitForOptions';
-import { IElementIsolate } from 'awaited-dom/base/interfaces/isolate';
+import { IElementIsolate, INodeIsolate } from 'awaited-dom/base/interfaces/isolate';
+import { INodeVisibility } from '@secret-agent/interfaces/INodeVisibility';
 import IAwaitedOptions from '../interfaces/IAwaitedOptions';
 import RequestGenerator, { getRequestIdOrUrl } from './Request';
 import CookieStorage, { createCookieStorage } from './CookieStorage';
@@ -89,19 +90,19 @@ export default class FrameEnvironment {
   }
 
   public get document(): SuperDocument {
-    const awaitedPath = new AwaitedPath('document');
+    const awaitedPath = new AwaitedPath(null, 'document');
     const awaitedOptions = { ...getState(this) };
     return createSuperDocument<IAwaitedOptions>(awaitedPath, awaitedOptions) as SuperDocument;
   }
 
   public get localStorage(): Storage {
-    const awaitedPath = new AwaitedPath('localStorage');
+    const awaitedPath = new AwaitedPath(null, 'localStorage');
     const awaitedOptions = { ...getState(this) };
     return createStorage<IAwaitedOptions>(awaitedPath, awaitedOptions) as Storage;
   }
 
   public get sessionStorage(): Storage {
-    const awaitedPath = new AwaitedPath('sessionStorage');
+    const awaitedPath = new AwaitedPath(null, 'sessionStorage');
     const awaitedOptions = { ...getState(this) };
     return createStorage<IAwaitedOptions>(awaitedPath, awaitedOptions) as Storage;
   }
@@ -115,9 +116,9 @@ export default class FrameEnvironment {
   public async fetch(request: Request | string, init?: IRequestInit): Promise<Response> {
     const requestInput = await getRequestIdOrUrl(request);
     const coreFrame = await getCoreFrameEnvironment(this);
-    const attachedState = await coreFrame.fetch(requestInput, init);
+    const nodePointer = await coreFrame.fetch(requestInput, init);
 
-    const awaitedPath = new AwaitedPath().withAttachedId(attachedState.id);
+    const awaitedPath = new AwaitedPath(null).withNodeId(null, nodePointer.id);
     return createResponse(awaitedPath, { ...getState(this) });
   }
 
@@ -128,7 +129,7 @@ export default class FrameEnvironment {
 
   public getComputedStyle(element: IElementIsolate, pseudoElement?: string): CSSStyleDeclaration {
     const { awaitedPath: elementAwaitedPath } = awaitedPathState.getState(element);
-    const awaitedPath = new AwaitedPath('window', [
+    const awaitedPath = new AwaitedPath(null, 'window', [
       'getComputedStyle',
       getAwaitedPathAsMethodArg(elementAwaitedPath),
       pseudoElement,
@@ -140,15 +141,21 @@ export default class FrameEnvironment {
     ) as CSSStyleDeclaration;
   }
 
-  public async getJsValue<T>(path: string): Promise<T> {
+  public async getComputedVisibility(node: INodeIsolate): Promise<INodeVisibility> {
+    if (!node) return { isVisible: false, nodeExists: false };
+    const { awaitedPath } = awaitedPathState.getState(node);
     const coreFrame = await getCoreFrameEnvironment(this);
-    return coreFrame.getJsValue<T>(path);
+    return coreFrame.getComputedVisibility(awaitedPath.toJSON());
   }
 
+  // @deprecated 2021-04-30: Replaced with getComputedVisibility
   public async isElementVisible(element: IElementIsolate): Promise<boolean> {
-    const { awaitedPath } = awaitedPathState.getState(element);
+    return await this.getComputedVisibility(element as any).then(x => x.isVisible);
+  }
+
+  public async getJsValue<T>(path: string): Promise<T> {
     const coreFrame = await getCoreFrameEnvironment(this);
-    return coreFrame.isElementVisible(awaitedPath.toJSON());
+    return coreFrame.getJsValue<T>(path);
   }
 
   public async waitForPaintingStable(options?: IWaitForOptions): Promise<void> {
@@ -165,6 +172,7 @@ export default class FrameEnvironment {
     element: ISuperElement,
     options?: IWaitForElementOptions,
   ): Promise<void> {
+    if (!element) throw new Error('Element being waited for is null');
     const { awaitedPath } = awaitedPathState.getState(element);
     const coreFrame = await getCoreFrameEnvironment(this);
     await coreFrame.waitForElement(awaitedPath.toJSON(), options);

client/lib/Request.ts

@@ -2,12 +2,12 @@ import FetchRequest from 'awaited-dom/impl/official-klasses/Request';
 import AwaitedPath from 'awaited-dom/base/AwaitedPath';
 import StateMachine from 'awaited-dom/base/StateMachine';
 import { IRequestInfo, IRequestInit } from 'awaited-dom/base/interfaces/official';
-import IAttachedState from 'awaited-dom/base/IAttachedState';
+import INodePointer from 'awaited-dom/base/INodePointer';
 import CoreFrameEnvironment from './CoreFrameEnvironment';
 
 interface IState {
   awaitedPath: AwaitedPath;
-  attachedState: IAttachedState;
+  nodePointer: INodePointer;
   remoteInitializerPromise: Promise<void>;
   coreFrame: Promise<CoreFrameEnvironment>;
 }
@@ -37,10 +37,10 @@ async function createRemoteInitializer(
 ): Promise<void> {
   const requestInput = await getRequestIdOrUrl(input);
   const coreFrame = await coreFramePromise;
-  const attachedState = await coreFrame.createRequest(requestInput, init);
-  const awaitedPath = new AwaitedPath().withAttachedId(attachedState.id);
+  const nodePointer = await coreFrame.createRequest(requestInput, init);
+  const awaitedPath = new AwaitedPath(null).withNodeId(null, nodePointer.id);
   setState(instance, {
-    attachedState,
+    nodePointer,
     awaitedPath,
   });
 }

client/lib/SetupAwaitedHandler.ts

@@ -1,39 +1,39 @@
 import AwaitedHandler, { NotImplementedError } from 'awaited-dom/base/AwaitedHandler';
 import AwaitedPath, { IJsPath } from 'awaited-dom/base/AwaitedPath';
 import Constructable from 'awaited-dom/base/Constructable';
-import IAttachedState from 'awaited-dom/base/IAttachedState';
+import INodePointer from 'awaited-dom/base/INodePointer';
 import IExecJsPathResult from '@secret-agent/interfaces/IExecJsPathResult';
-import getAttachedStateFnName from '@secret-agent/interfaces/getAttachedStateFnName';
+import getNodePointerFnName from '@secret-agent/interfaces/getNodePointerFnName';
 import IAwaitedOptions from '../interfaces/IAwaitedOptions';
 import CoreFrameEnvironment from './CoreFrameEnvironment';
 
-// Sets up AwaitedHandler initializer hooks. See Noderdom/AwaitedDOM
-AwaitedHandler.delegate = {
+export const delegate = {
   getProperty,
   setProperty,
   construct,
   runMethod,
   runStatic,
-  loadState,
+  createNodePointer,
 };
 
-export async function getProperty<T, TClass>(
+// Sets up AwaitedHandler initializer hooks. See Noderdom/AwaitedDOM
+AwaitedHandler.delegate = delegate;
+
+async function getProperty<T, TClass>(
   self: AwaitedHandler<TClass>,
   instance: TClass,
   name: string,
 ): Promise<T> {
-  const state = self.getState(instance);
-  await awaitRemoteInitializer(state);
-  const awaitedPath = state.awaitedPath as AwaitedPath;
-  const { coreFrame } = state.awaitedOptions as IAwaitedOptions;
-  const awaitedCoreFrame = await coreFrame;
-  const finalPath = awaitedPath.addProperty(name).toJSON();
-  const result = await execJsPath<TClass, T>(self, awaitedCoreFrame, instance, finalPath);
+  const { awaitedPath, coreFrame } = await getAwaitedState(self, instance);
+
+  const finalPath = awaitedPath.addProperty(instance as any, name);
+
+  const result = await execJsPath<TClass, T>(self, coreFrame, instance, finalPath.toJSON());
 
   return cleanResult(self, instance, result);
 }
 
-export async function setProperty<T, TClass>(
+async function setProperty<T, TClass>(
   self: AwaitedHandler<TClass>,
   instance: TClass,
   name: string,
@@ -43,50 +43,57 @@ export async function setProperty<T, TClass>(
   self.setState(instance, { [name]: value });
 }
 
-export async function runMethod<T, TClass>(
+async function runMethod<T, TClass>(
   self: AwaitedHandler<TClass>,
   instance: TClass,
   name: string,
   args: any[],
 ): Promise<T> {
-  await awaitRemoteInitializer(instance);
-  const state = self.getState(instance);
-  const awaitedPath = state.awaitedPath as AwaitedPath;
-  const { coreFrame } = state.awaitedOptions as IAwaitedOptions;
-  const awaitedCoreFrame = await coreFrame;
-  const finalPath = awaitedPath.addMethod(name, ...args).toJSON();
-  const result = await execJsPath<TClass, T>(self, awaitedCoreFrame, instance, finalPath);
+  const { awaitedPath, coreFrame } = await getAwaitedState(self, instance);
+  const finalPath = awaitedPath.addMethod(instance as any, name, ...args);
+
+  const result = await execJsPath<TClass, T>(self, coreFrame, instance, finalPath.toJSON());
   return cleanResult(self, instance, result);
 }
 
-export async function loadState<TClass>(
+async function createNodePointer<TClass>(
   self: AwaitedHandler<TClass>,
   instance: TClass,
-  properties?: string[],
-): Promise<IAttachedState> {
-  await awaitRemoteInitializer(instance);
-  const state = self.getState(instance);
-  const awaitedPath = state.awaitedPath as AwaitedPath;
-  const { coreFrame } = state.awaitedOptions as IAwaitedOptions;
-  const awaitedCoreFrame = await coreFrame;
-  const finalPath = awaitedPath.addMethod(getAttachedStateFnName, properties).toJSON();
-  const result = await execJsPath<TClass, null>(self, awaitedCoreFrame, instance, finalPath);
+): Promise<INodePointer> {
+  const { awaitedPath, coreFrame } = await getAwaitedState(self, instance);
+  const finalPath = awaitedPath.addMethod(instance as any, getNodePointerFnName).toJSON();
+  const result = await execJsPath<TClass, null>(self, coreFrame, instance, finalPath);
 
-  return result?.attachedState as IAttachedState;
+  return result?.nodePointer;
 }
 
-export function runStatic<T, TClass>(
+function runStatic<T, TClass>(
   self: AwaitedHandler<TClass>,
   _klass: Constructable<TClass>,
   name: string,
 ): T {
   throw new NotImplementedError(`${self.className}.${name} static method not implemented`);
 }
 
-export function construct<TClass>(self: AwaitedHandler<TClass>): TClass {
+function construct<TClass>(self: AwaitedHandler<TClass>): TClass {
   throw new NotImplementedError(`${self.className} constructor not implemented`);
 }
 
+async function getAwaitedState<TClass>(
+  self: AwaitedHandler<TClass>,
+  instance: TClass,
+): Promise<{
+  awaitedPath: AwaitedPath;
+  coreFrame: CoreFrameEnvironment;
+}> {
+  await awaitRemoteInitializer(instance);
+  const state = self.getState(instance);
+  const awaitedPath = state.awaitedPath as AwaitedPath;
+  const { coreFrame } = state.awaitedOptions as IAwaitedOptions;
+  const awaitedCoreFrame = await coreFrame;
+  return { awaitedPath, coreFrame: awaitedCoreFrame };
+}
+
 export function getAwaitedPathAsMethodArg(awaitedPath: AwaitedPath): string {
   return `$$jsPath=${JSON.stringify(awaitedPath.toJSON())}`;
 }
@@ -121,12 +128,12 @@ function cleanResult<T, TClass>(
   result: IExecJsPathResult<T>,
 ): T {
   if (!result) return null;
-  if (!result?.attachedState) return result?.value;
 
-  self.setState(instance, {
-    attachedState: result.attachedState,
-  });
-  delete result.attachedState;
+  if (result.nodePointer) {
+    self.setState(instance, {
+      nodePointer: result.nodePointer,
+    });
+  }
 
   return result.value;
 }

client/lib/Tab.ts

@@ -11,9 +11,10 @@ import IWaitForResourceOptions from '@secret-agent/interfaces/IWaitForResourceOp
 import IWaitForElementOptions from '@secret-agent/interfaces/IWaitForElementOptions';
 import Response from 'awaited-dom/impl/official-klasses/Response';
 import IWaitForOptions from '@secret-agent/interfaces/IWaitForOptions';
-import { IElementIsolate } from 'awaited-dom/base/interfaces/isolate';
+import { IElementIsolate, INodeIsolate } from 'awaited-dom/base/interfaces/isolate';
 import IScreenshotOptions from '@secret-agent/interfaces/IScreenshotOptions';
 import AwaitedPath from 'awaited-dom/base/AwaitedPath';
+import { INodeVisibility } from '@secret-agent/interfaces/INodeVisibility';
 import CoreTab from './CoreTab';
 import Resource, { createResource } from './Resource';
 import IWaitForResourceFilter from '../interfaces/IWaitForResourceFilter';
@@ -160,8 +161,13 @@ export default class Tab extends AwaitedEventTarget<IEventType> {
     return await this.mainFrameEnvironment.getJsValue(path);
   }
 
+  // @deprecated 2021-04-30: Replaced with getComputedVisibility
   public async isElementVisible(element: IElementIsolate): Promise<boolean> {
-    return await this.mainFrameEnvironment.isElementVisible(element);
+    return await this.getComputedVisibility(element as any).then(x => x.isVisible);
+  }
+
+  public async getComputedVisibility(node: INodeIsolate): Promise<INodeVisibility> {
+    return await this.mainFrameEnvironment.getComputedVisibility(node);
   }
 
   public async takeScreenshot(options?: IScreenshotOptions): Promise<Buffer> {

client/lib/WebsocketResource.ts

@@ -79,7 +79,7 @@ export function createWebsocketResource(
   const resource = new WebsocketResource();
   const request = createResourceRequest(coreTab, resourceMeta.id);
   const response = createResourceResponse(coreTab, resourceMeta.id);
-  const awaitedPath = new AwaitedPath('resources', String(resourceMeta.id));
+  const awaitedPath = new AwaitedPath(null, 'resources', String(resourceMeta.id));
   setState(resource, { coreTab, resource: resourceMeta, request, response, awaitedPath });
   return resource;
 }

client/package.json

@@ -10,7 +10,7 @@
     "@secret-agent/commons": "1.4.1-alpha.4",
     "@secret-agent/interfaces": "1.4.1-alpha.4",
     "@secret-agent/replay": "1.4.1-alpha.4",
-    "awaited-dom": "1.1.12",
+    "awaited-dom": "1.2.1",
     "uuid": "^8.3.2",
     "ws": "^7.4.4"
   },