Unify component discovery code and use webassembly instead of 'client'

Author: javiercn

src/Components/Web.JS/dist/Release/blazor.server.js

@@ -7,11 +7,12 @@ import { shouldAutoStart } from './BootCommon';
 import { RenderQueue } from './Platform/Circuits/RenderQueue';
 import { ConsoleLogger } from './Platform/Logging/Loggers';
 import { LogLevel, Logger } from './Platform/Logging/Logger';
-import { discoverComponents, CircuitDescriptor } from './Platform/Circuits/CircuitManager';
+import { CircuitDescriptor } from './Platform/Circuits/CircuitManager';
 import { setEventDispatcher } from './Rendering/RendererEventDispatcher';
 import { resolveOptions, CircuitStartOptions } from './Platform/Circuits/CircuitStartOptions';
 import { DefaultReconnectionHandler } from './Platform/Circuits/DefaultReconnectionHandler';
 import { attachRootComponentToLogicalElement } from './Rendering/Renderer';
+import { discoverComponents, ServerComponentDescriptor } from './Services/ComponentDescriptorDiscovery';
 
 let renderingFailed = false;
 let started = false;
@@ -29,7 +30,7 @@ async function boot(userOptions?: Partial<CircuitStartOptions>): Promise<void> {
   options.reconnectionHandler = options.reconnectionHandler || window['Blazor'].defaultReconnectionHandler;
   logger.log(LogLevel.Information, 'Starting up blazor server-side application.');
 
-  const components = discoverComponents(document);
+  const components = discoverComponents(document, 'server') as ServerComponentDescriptor[];
   const circuit = new CircuitDescriptor(components);
 
   const initialConnection = await initializeConnection(options, logger, circuit);

src/Components/Web.JS/dist/Release/blazor.webassembly.js

@@ -11,7 +11,8 @@ import { WebAssemblyConfigLoader } from './Platform/WebAssemblyConfigLoader';
 import { BootConfigResult } from './Platform/BootConfig';
 import { Pointer } from './Platform/Platform';
 import { WebAssemblyStartOptions } from './Platform/WebAssemblyStartOptions';
-import { discoverComponents, WebAssemblyComponentAttacher } from './Platform/WebAssemblyComponentAttacher';
+import { WebAssemblyComponentAttacher } from './Platform/WebAssemblyComponentAttacher';
+import { discoverComponents, WebAssemblyComponentDescriptor } from './Services/ComponentDescriptorDiscovery';
 
 let started = false;
 
@@ -76,7 +77,7 @@ async function boot(options?: Partial<WebAssemblyStartOptions>): Promise<void> {
 
   // Leverage the time while we are loading boot.config.json from the network to discover any potentially registered component on
   // the document.
-  const discoveredComponents = discoverComponents(document);
+  const discoveredComponents = discoverComponents(document, 'webassembly') as WebAssemblyComponentDescriptor[];
   const componentAttacher = new WebAssemblyComponentAttacher(discoveredComponents);
   window['Blazor']._internal.registeredComponents = {
     getRegisteredComponentsCount: () => componentAttacher.getCount(),

src/Components/Web.JS/src/Boot.Server.ts

@@ -1,12 +1,13 @@
 import { internalFunctions as navigationManagerFunctions } from '../../Services/NavigationManager';
 import { toLogicalRootCommentElement, LogicalElement } from '../../Rendering/LogicalElements';
+import { ServerComponentDescriptor } from '../../Services/ComponentDescriptorDiscovery';
 
 export class CircuitDescriptor {
   public circuitId?: string;
 
-  public components: ComponentDescriptor[];
+  public components: ServerComponentDescriptor[];
 
-  public constructor(components: ComponentDescriptor[]) {
+  public constructor(components: ServerComponentDescriptor[]) {
     this.circuitId = undefined;
     this.components = components;
   }
@@ -54,224 +55,3 @@ export class CircuitDescriptor {
   }
 }
 
-interface ComponentMarker {
-  type: string;
-  sequence: number;
-  descriptor: string;
-}
-
-export class ComponentDescriptor {
-  public type: string;
-
-  public start: Node;
-
-  public end?: Node;
-
-  public sequence: number;
-
-  public descriptor: string;
-
-  public constructor(type: string, start: Node, end: Node | undefined, sequence: number, descriptor: string) {
-    this.type = type;
-    this.start = start;
-    this.end = end;
-    this.sequence = sequence;
-    this.descriptor = descriptor;
-  }
-
-  public toRecord(): ComponentMarker {
-    const result = { type: this.type, sequence: this.sequence, descriptor: this.descriptor };
-    return result;
-  }
-}
-
-export function discoverComponents(document: Document): ComponentDescriptor[] {
-  const componentComments = resolveComponentComments(document);
-  const discoveredComponents: ComponentDescriptor[] = [];
-  for (let i = 0; i < componentComments.length; i++) {
-    const componentComment = componentComments[i];
-    const entry = new ComponentDescriptor(
-      componentComment.type,
-      componentComment.start,
-      componentComment.end,
-      componentComment.sequence,
-      componentComment.descriptor,
-    );
-
-    discoveredComponents.push(entry);
-  }
-
-  return discoveredComponents.sort((a, b) => a.sequence - b.sequence);
-}
-
-
-interface ComponentComment {
-  type: 'server' | 'client';
-  sequence: number;
-  descriptor: string;
-  start: Node;
-  end?: Node;
-  prerenderId?: string;
-}
-
-function resolveComponentComments(node: Node): ComponentComment[] {
-  if (!node.hasChildNodes()) {
-    return [];
-  }
-
-  const result: ComponentComment[] = [];
-  const childNodeIterator = new ComponentCommentIterator(node.childNodes);
-  while (childNodeIterator.next() && childNodeIterator.currentElement) {
-    const componentComment = getComponentComment(childNodeIterator);
-    if (componentComment) {
-      result.push(componentComment);
-    } else {
-      const childResults = resolveComponentComments(childNodeIterator.currentElement);
-      for (let j = 0; j < childResults.length; j++) {
-        const childResult = childResults[j];
-        result.push(childResult);
-      }
-    }
-  }
-
-  return result;
-}
-
-const blazorCommentRegularExpression = /\W*Blazor:[^{]*(?<descriptor>.*)$/;
-
-function getComponentComment(commentNodeIterator: ComponentCommentIterator): ComponentComment | undefined {
-  const candidateStart = commentNodeIterator.currentElement;
-
-  if (!candidateStart || candidateStart.nodeType !== Node.COMMENT_NODE) {
-    return;
-  }
-  if (candidateStart.textContent) {
-    const componentStartComment = new RegExp(blazorCommentRegularExpression);
-    const definition = componentStartComment.exec(candidateStart.textContent);
-    const json = definition && definition.groups && definition.groups['descriptor'];
-
-    if (json) {
-      try {
-        return createServerComponentComment(json, candidateStart, commentNodeIterator);
-      } catch (error) {
-        throw new Error(`Found malformed component comment at ${candidateStart.textContent}`);
-      }
-    } else {
-      return;
-    }
-  }
-}
-
-function createServerComponentComment(json: string, start: Node, iterator: ComponentCommentIterator): ComponentComment | undefined {
-  const payload = JSON.parse(json) as ComponentComment;
-  const { type, sequence, descriptor, prerenderId } = payload;
-  if (type !== 'server' && type !== 'client') {
-    throw new Error(`Invalid component type '${type}'.`);
-  }
-
-  // We should not encounter this, but in the case we do, simply ignore it.
-  if (type === 'client') {
-    return undefined;
-  }
-
-  if (!descriptor) {
-    throw new Error('descriptor must be defined when using a descriptor.');
-  }
-
-  if (sequence === undefined) {
-    throw new Error('sequence must be defined when using a descriptor.');
-  }
-
-  if (!Number.isInteger(sequence)) {
-    throw new Error(`Error parsing the sequence '${sequence}' for component '${json}'`);
-  }
-
-  if (!prerenderId) {
-    return {
-      type,
-      sequence: sequence,
-      descriptor,
-      start,
-    };
-  } else {
-    const end = getComponentEndComment(prerenderId, iterator);
-    if (!end) {
-      throw new Error(`Could not find an end component comment for '${start}'`);
-    }
-
-    return {
-      type,
-      sequence,
-      descriptor,
-      start,
-      prerenderId,
-      end,
-    };
-  }
-}
-
-function getComponentEndComment(prerenderedId: string, iterator: ComponentCommentIterator): ChildNode | undefined {
-  while (iterator.next() && iterator.currentElement) {
-    const node = iterator.currentElement;
-    if (node.nodeType !== Node.COMMENT_NODE) {
-      continue;
-    }
-    if (!node.textContent) {
-      continue;
-    }
-
-    const definition = new RegExp(blazorCommentRegularExpression).exec(node.textContent);
-    const json = definition && definition[1];
-    if (!json) {
-      continue;
-    }
-
-    validateEndComponentPayload(json, prerenderedId);
-
-    return node;
-  }
-
-  return undefined;
-}
-
-function validateEndComponentPayload(json: string, prerenderedId: string): void {
-  const payload = JSON.parse(json) as ComponentComment;
-  if (Object.keys(payload).length !== 1) {
-    throw new Error(`Invalid end of component comment: '${json}'`);
-  }
-  const prerenderedEndId = payload.prerenderId;
-  if (!prerenderedEndId) {
-    throw new Error(`End of component comment must have a value for the prerendered property: '${json}'`);
-  }
-  if (prerenderedEndId !== prerenderedId) {
-    throw new Error(`End of component comment prerendered property must match the start comment prerender id: '${prerenderedId}', '${prerenderedEndId}'`);
-  }
-}
-
-class ComponentCommentIterator {
-
-  private childNodes: NodeListOf<ChildNode>;
-
-  private currentIndex: number;
-
-  private length: number;
-
-  public currentElement: ChildNode | undefined;
-
-  public constructor(childNodes: NodeListOf<ChildNode>) {
-    this.childNodes = childNodes;
-    this.currentIndex = -1;
-    this.length = childNodes.length;
-  }
-
-  public next(): boolean {
-    this.currentIndex++;
-    if (this.currentIndex < this.length) {
-      this.currentElement = this.childNodes[this.currentIndex];
-      return true;
-    } else {
-      this.currentElement = undefined;
-      return false;
-    }
-  }
-}