TypeScript dom5.insertBefore函数代码示例

  private async processFile(file: File): Promise<File> {
    if (file.path !== this.entrypoint) {
      return file;
    }
    const contents = await getFileContents(file);
    const document = parse5.parse(contents);

    const babelHelpersFragment =
        parse5.parseFragment('\n\n<script></script>\n\n');
    dom5.setTextContent(
        babelHelpersFragment.childNodes![1]!,
        await fs.readFile(
            path.join(__dirname, 'babel-helpers.min.js'), 'utf-8'));

    const firstScriptOrImport = dom5.nodeWalk(document, scriptOrImport);
    if (firstScriptOrImport) {
      dom5.insertBefore(
          firstScriptOrImport.parentNode!,
          firstScriptOrImport,
          babelHelpersFragment);
    } else {
      const head =
          dom5.query(document, dom5.predicates.hasTagName('head')) || document;
      dom5.append(head, babelHelpersFragment);
    }

    const newFile = file.clone();
    newFile.contents = new Buffer(parse5.serialize(document), 'utf-8');
    return newFile;
  }

export function prepend(parent: ASTNode, node: ASTNode) {
  if (parent.childNodes && parent.childNodes.length) {
    dom5.insertBefore(parent, parent.childNodes[0], node);
  } else {
    dom5.append(parent, node);
  }
}

export function addCustomElementsEs5Adapter(html: string): string {
  // Only modify this file if we find a web components polyfill. This is a
  // heuristic to identify the entry point HTML file. Ultimately we should
  // explicitly transform only the entry point by having the project config.
  if (!webcomponentsLoaderRegex.test(html)) {
    return html;
  }
  const parsed = parse5.parse(html, {locationInfo: true});
  const script = dom5.nodeWalk(parsed, webcomponentsLoaderMatcher);
  if (!script) {
    return html;
  }

  // Collect important dom references & create fragments for injection.
  const loaderScriptUrl = dom5.getAttribute(script, 'src')!;
  const adapterScriptUrl =
      url.resolve(loaderScriptUrl, 'custom-elements-es5-adapter.js');
  const es5AdapterFragment = parse5.parseFragment(`
    <script>if (!window.customElements) { document.write('<!--'); }</script>
    <script type="text/javascript" src="${adapterScriptUrl}"></script>
    <!--! do not remove -->
`);

  dom5.insertBefore(script.parentNode, script, es5AdapterFragment);
  return parse5.serialize(parsed);
}

export function insertAllBefore(
    target: ASTNode, after: ASTNode, nodes: ASTNode[]) {
  let lastNode = after;
  for (let n = nodes.length - 1; n >= 0; n--) {
    const node = nodes[n];
    dom5.insertBefore(target, lastNode, node);
    lastNode = node;
  }
}

  /**
   * Add HTML Import elements for each file in the bundle.  Efforts are made
   * to ensure that imports are injected prior to any eager imports of other
   * bundles which are known to depend on them, to preserve expectations of
   * evaluation order.
   */
  private _injectHtmlImportsForBundle(ast: ASTNode) {
    // Gather all the document's direct html imports.  We want the direct (not
    // transitive) imports only here, because we'll be using their AST nodes
    // as targets to prepended injected imports to.
    const existingImports = [
      ...this.document.getFeatures(
          {kind: 'html-import', noLazyImports: true, imported: false})
    ].filter((i) => !i.lazy && i.document !== undefined);
    const existingImportDependencies = new Map<ResolvedUrl, ResolvedUrl[]>();
    for (const {url, document} of existingImports) {
      existingImportDependencies.set(
          url,
          [...document!.getFeatures({
            kind: 'html-import',
            imported: true,
            noLazyImports: true,
          })].filter((i) => i.lazy === false && i.document !== undefined)
              .map((i) => i.document!.url));
    }
    // Every HTML file in the bundle is a candidate for injection into the
    // document.
    for (const importUrl of this.assignedBundle.bundle.files) {
      // We only want to inject an HTML import to an HTML file.
      if (getFileExtension(importUrl) !== '.html') {
        continue;
      }

      // We don't want to inject the bundle into itself.
      if (this.assignedBundle.url === importUrl) {
        continue;
      }

      // If there is an existing import in the document that matches the
      // import URL already, we don't need to inject one.
      if (existingImports.find(
              (e) =>
                  e.document !== undefined && e.document.url === importUrl)) {
        continue;
      }

      // We are looking for the earliest eager import of an html document
      // which has a dependency on the html import we want to inject.
      let prependTarget = undefined;

      // We are only concerned with imports that are not of files in this
      // bundle.
      for (const existingImport of existingImports.filter(
               (e) => e.document !== undefined &&
                   !this.assignedBundle.bundle.files.has(e.document.url))) {
        // If the existing import has a dependency on the import we are
        // about to inject, it may be our new target.
        if (existingImportDependencies.get(existingImport.document!.url)!
                .indexOf(importUrl) !== -1) {
          const newPrependTarget = dom5.query(
              ast, (node) => isSameNode(node, existingImport.astNode));

          // IF we don't have a target already or if the old target comes
          // after the new one in the source code, the new one will replace
          // the old one.
          if (newPrependTarget &&
              (!prependTarget ||
               inSourceOrder(newPrependTarget, prependTarget))) {
            prependTarget = newPrependTarget;
          }
        }
      }

      // Inject the new html import into the document.
      const relativeImportUrl = this.bundler.analyzer.urlResolver.relative(
          this.assignedBundle.url, importUrl);
      const newHtmlImport = this._createHtmlImport(relativeImportUrl);
      if (prependTarget) {
        dom5.insertBefore(
            prependTarget.parentNode!, prependTarget, newHtmlImport);
      } else {
        const hiddenDiv = this._findOrCreateHiddenDiv(ast);
        dom5.append(hiddenDiv.parentNode!, newHtmlImport);
      }
    }
  }