@babel/traverse#Binding TypeScript Examples

private findOrPushBindingIndex(binding: Binding): number {
    const bindingIndex = this.findBindingIndex(binding);
    if (bindingIndex === -1) {
      this.innerBindingMap.push(binding.identifier.name, binding);
      this.map.get(binding.identifier.name).push([]);
      return this.findBindingIndex(binding);
    }
    return bindingIndex;
  }

/**
   * Does a visit of all nodes within the scope of the giving binding
   * @param binding The binding to set traversing bounds
   * @param varName The variable name for the binding
   * @param visitor A visitor object
   */
  protected bindingTraverse(binding: Binding, varName: string, visitor: Visitor): void {
    binding.scope.traverse(binding.scope.block, {
      ...visitor,
      Scope: (path) => {
        if (!path.scope.bindingIdentifierEquals(varName, binding.identifier)) {
          path.skip();
        }
      },
    });
  }

resolveStyledComponentsImport = (
  node: CallExpression,
  binding: Binding,
): { exportName?: string; moduleName?: string } | undefined => {
  if (node.callee.type !== 'Identifier') {
    return;
  }

  const resolved = resolveImport(binding.scope.getBinding(node.callee.name)); // eslint-disable-line no-use-before-define

  if (
    resolved &&
    resolved.moduleName &&
    (isModule(resolved.moduleName, 'styled-components') || isModule(resolved.moduleName, '@emotion/styled'))
  ) {
    if (node.arguments.length > 0 && node.arguments[0].type === 'Identifier') {
      return resolveImport(binding.scope.getBinding(node.arguments[0].name)); // eslint-disable-line no-use-before-define
    }
  }
}

private findOrPushBindingIndex(binding: Binding): number {
    const bindingIndex = this.findBindingIndex(binding);
    if (bindingIndex === -1) {
      this.innerBindingMap.push(binding.identifier.name, binding);
      this.map.get(binding.identifier.name).push([]);
      return this.findBindingIndex(binding);
    }
    return bindingIndex;
  }

/**
   * Does a visit of all nodes within the scope of the giving binding
   * @param binding The binding to set traversing bounds
   * @param varName The variable name for the binding
   * @param visitor A visitor object
   */
  protected bindingTraverse(binding: Binding, varName: string, visitor: Visitor): void {
    binding.scope.traverse(binding.scope.block, {
      ...visitor,
      Scope: (path) => {
        if (!path.scope.bindingIdentifierEquals(varName, binding.identifier)) {
          path.skip();
        }
      },
    });
  }

resolveLocalImportBinding = (binding: Binding, moduleName: string, exportName: string): Binding | undefined => {
  if (binding.path.hub.file.opts.filename) {
    // resolve and parse file
    const filePath = resolveFilePathSync(binding.path, moduleName);

    if (!filePath) {
      return undefined;
    }

    const parsedFile = loadFileSync(filePath, binding.path.hub.file.opts.parserOpts);
    const exploded = explodeModule(parsedFile.path.parent);
    const exportStatement = exploded.exports.find((e: { external: string }) => e.external === exportName);

    if (!exportStatement) {
      return undefined;
    }

    return parsedFile.scope.getBinding(exportStatement.local);
  }

  return undefined;
}

getImportedJsxComponent = (binding: Binding | undefined): string | undefined => {
  const resolved = resolveImport(binding);

  // follow local imports
  if (
    resolved &&
    resolved.moduleName &&
    (resolved.moduleName.startsWith('./') || resolved.moduleName.startsWith('../')) &&
    resolved.exportName &&
    binding
  ) {
    const resolvedBinding = resolveLocalImportBinding(binding, resolved.moduleName, resolved.exportName);
    return getImportedJsxComponent(resolvedBinding);
  }

  if (
    resolved &&
    resolved.exportName &&
    resolved.moduleName &&
    isModule(resolved.moduleName, 'react-optimized-image')
  ) {
    return simplifyExportName(resolved.exportName, resolved.moduleName);
  }
}

resolveRequireExportName = (node: VariableDeclarator, binding: Binding): string | undefined => {
  // check for const { Svg } = require('react-optimized-image') calls
  if (node.id.type === 'ObjectPattern') {
    return (node.id.properties.find(
      (property) =>
        property.type === 'ObjectProperty' &&
        property.value.type === 'Identifier' &&
        property.value.name === binding.identifier.name,
    ) as ObjectProperty).key.name;
  }

  // check for require('react-optimized-image').default calls
  if (
    node.init &&
    node.init.type === 'MemberExpression' &&
    node.init.object.type === 'CallExpression' &&
    node.init.property.type === 'Identifier'
  ) {
    return node.init.property.name;
  }
}

forEach(_callbackfn: (value: V[], key: Binding, map: Map<Binding, V[]>) => void, _thisArg?: unknown): void {
    throw new Error('Method not implemented.');
  }

/**
 * Map that supports multiple values in one key
 */
export default class BindingArrayMap<V> implements Map<Binding, V[]> {
  private map: ArrayMap<string, V[]> = new ArrayMap<string, V[]>();
  private innerBindingMap: ArrayMap<string, Binding> = new ArrayMap<string, Binding>();

  get size(): number {
    let size = 0;
    this.innerBindingMap.forEach((e) => {
      size += e.length;
    });
    return size;
  }

  get(key: Binding): V[] {
    const bindingIndex = this.findBindingIndex(key);
    return bindingIndex === -1 ? [] : this.map.get(key.identifier.name)[bindingIndex];
  }

  push(key: Binding, value: V): void {
    const bindingIndex = this.findOrPushBindingIndex(key);
    this.map.get(key.identifier.name)[bindingIndex].push(value);
  }

  forEachElement(key: Binding, callbackfn: (value: V) => void): void {
    this.get(key).forEach(callbackfn);
  }

  private findBindingIndex(binding: Binding): number {
    return this.innerBindingMap.get(binding.identifier.name).findIndex((e) => e === binding);
  }

  private findOrPushBindingIndex(binding: Binding): number {
    const bindingIndex = this.findBindingIndex(binding);
    if (bindingIndex === -1) {
      this.innerBindingMap.push(binding.identifier.name, binding);
      this.map.get(binding.identifier.name).push([]);
      return this.findBindingIndex(binding);
    }
    return bindingIndex;
  }

  clear(): void {
    throw new Error('Method not implemented.');
  }
  delete(_key: Binding): boolean {
    throw new Error('Method not implemented.');
  }
  forEach(_callbackfn: (value: V[], key: Binding, map: Map<Binding, V[]>) => void, _thisArg?: unknown): void {
    throw new Error('Method not implemented.');
  }
  has(_key: Binding): boolean {
    throw new Error('Method not implemented.');
  }
  set(_key: Binding, _value: V[]): this {
    throw new Error('Method not implemented.');
  }
  [Symbol.iterator](): IterableIterator<[Binding, V[]]> {
    throw new Error('Method not implemented.');
  }
  entries(): IterableIterator<[Binding, V[]]> {
    throw new Error('Method not implemented.');
  }
  keys(): IterableIterator<Binding> {
    throw new Error('Method not implemented.');
  }
  values(): IterableIterator<V[]> {
    throw new Error('Method not implemented.');
  }
  [Symbol.toStringTag]: string;
}

get(key: Binding): V[] {
    const bindingIndex = this.findBindingIndex(key);
    return bindingIndex === -1 ? [] : this.map.get(key.identifier.name)[bindingIndex];
  }

push(key: Binding, value: V): void {
    const bindingIndex = this.findOrPushBindingIndex(key);
    this.map.get(key.identifier.name)[bindingIndex].push(value);
  }

forEachElement(key: Binding, callbackfn: (value: V) => void): void {
    this.get(key).forEach(callbackfn);
  }

private findBindingIndex(binding: Binding): number {
    return this.innerBindingMap.get(binding.identifier.name).findIndex((e) => e === binding);
  }

delete(_key: Binding): boolean {
    throw new Error('Method not implemented.');
  }

has(_key: Binding): boolean {
    throw new Error('Method not implemented.');
  }

keys(): IterableIterator<Binding> {
    throw new Error('Method not implemented.');
  }

set(_key: Binding, _value: V[]): this {
    throw new Error('Method not implemented.');
  }

[Symbol.iterator](): IterableIterator<[Binding, V[]]> {
    throw new Error('Method not implemented.');
  }

entries(): IterableIterator<[Binding, V[]]> {
    throw new Error('Method not implemented.');
  }

keys(): IterableIterator<Binding> {
    throw new Error('Method not implemented.');
  }

private innerBindingMap: ArrayMap<string, Binding> = new ArrayMap<string, Binding>();

/**
 * Map that supports multiple values in one key
 */
export default class BindingArrayMap<V> implements Map<Binding, V[]> {
  private map: ArrayMap<string, V[]> = new ArrayMap<string, V[]>();
  private innerBindingMap: ArrayMap<string, Binding> = new ArrayMap<string, Binding>();

  get size(): number {
    let size = 0;
    this.innerBindingMap.forEach((e) => {
      size += e.length;
    });
    return size;
  }

  get(key: Binding): V[] {
    const bindingIndex = this.findBindingIndex(key);
    return bindingIndex === -1 ? [] : this.map.get(key.identifier.name)[bindingIndex];
  }

  push(key: Binding, value: V): void {
    const bindingIndex = this.findOrPushBindingIndex(key);
    this.map.get(key.identifier.name)[bindingIndex].push(value);
  }

  forEachElement(key: Binding, callbackfn: (value: V) => void): void {
    this.get(key).forEach(callbackfn);
  }

  private findBindingIndex(binding: Binding): number {
    return this.innerBindingMap.get(binding.identifier.name).findIndex((e) => e === binding);
  }

  private findOrPushBindingIndex(binding: Binding): number {
    const bindingIndex = this.findBindingIndex(binding);
    if (bindingIndex === -1) {
      this.innerBindingMap.push(binding.identifier.name, binding);
      this.map.get(binding.identifier.name).push([]);
      return this.findBindingIndex(binding);
    }
    return bindingIndex;
  }

  clear(): void {
    throw new Error('Method not implemented.');
  }
  delete(_key: Binding): boolean {
    throw new Error('Method not implemented.');
  }
  forEach(_callbackfn: (value: V[], key: Binding, map: Map<Binding, V[]>) => void, _thisArg?: any): void {
    throw new Error('Method not implemented.');
  }
  has(_key: Binding): boolean {
    throw new Error('Method not implemented.');
  }
  set(_key: Binding, _value: V[]): this {
    throw new Error('Method not implemented.');
  }
  [Symbol.iterator](): IterableIterator<[Binding, V[]]> {
    throw new Error('Method not implemented.');
  }
  entries(): IterableIterator<[Binding, V[]]> {
    throw new Error('Method not implemented.');
  }
  keys(): IterableIterator<Binding> {
    throw new Error('Method not implemented.');
  }
  values(): IterableIterator<V[]> {
    throw new Error('Method not implemented.');
  }
  [Symbol.toStringTag]: string;
}

private innerBindingMap: ArrayMap<string, Binding> = new ArrayMap<string, Binding>();

entries(): IterableIterator<[Binding, V[]]> {
    throw new Error('Method not implemented.');
  }

[Symbol.iterator](): IterableIterator<[Binding, V[]]> {
    throw new Error('Method not implemented.');
  }

set(_key: Binding, _value: V[]): this {
    throw new Error('Method not implemented.');
  }

has(_key: Binding): boolean {
    throw new Error('Method not implemented.');
  }

forEach(_callbackfn: (value: V[], key: Binding, map: Map<Binding, V[]>) => void, _thisArg?: any): void {
    throw new Error('Method not implemented.');
  }