Class MainDOMSource

dom/src/MainDOMSource.ts:87–215

}

export class MainDOMSource implements DOMSource {

  constructor(private _rootElement$: Stream<Element>,
              private _sanitation$: Stream<null>,
              private _namespace: Array<string> = [],
              public _isolateModule: IsolateModule,
              public _delegators: Map<string, EventDelegator>,
              private _name: string) {
    this.isolateSource = isolateSource;
    this.isolateSink = (sink, scope) => {
      const prevFullScope = getFullScope(this._namespace);
      const nextFullScope = [prevFullScope, scope].filter(x => !!x).join('-');
      return internalIsolateSink(sink, nextFullScope) as Stream<VNode>;
    };
  }

  public elements(): MemoryStream<Element> {
    let output$: Stream<Element | Array<Element>>;
    if (this._namespace.length === 0) {
      output$ = this._rootElement$;
    } else {
      const elementFinder = new ElementFinder(this._namespace, this._isolateModule);
      output$ = this._rootElement$.map(el => elementFinder.call(el));
    }
    const out: DevToolEnabledSource & MemoryStream<Element> = adapt(output$.remember());
    out._isCycleSource = this._name;
    return out;
  }

  get namespace(): Array<string> {
    return this._namespace;
  }

  public select(selector: string): DOMSource {
    if (typeof selector !== 'string') {
      throw new Error(`DOM driver's select() expects the argument to be a ` +
        `string as a CSS selector`);
    }
    if (selector === 'document') {
      return new DocumentDOMSource(this._name);
    }
    if (selector === 'body') {
      return new BodyDOMSource(this._name);
    }
    const trimmedSelector = selector.trim();
    const childNamespace = trimmedSelector === `:root` ?
      this._namespace :
      this._namespace.concat(trimmedSelector);
    return new MainDOMSource(
      this._rootElement$,
      this._sanitation$,
      childNamespace,
      this._isolateModule,
      this._delegators,
      this._name,
    );
  }