.

Author: wooorm

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

.github/workflows/bb.yml

@@ -0,0 +1,13 @@
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: unifiedjs/beep-boop-beta@main
+        with:
+          repo-token: ${{secrets.GITHUB_TOKEN}}
+name: bb
+on:
+  issues:
+    types: [closed, edited, labeled, opened, reopened, unlabeled]
+  pull_request_target:
+    types: [closed, edited, labeled, opened, reopened, unlabeled]

.github/workflows/main.yml

@@ -0,0 +1,21 @@
+jobs:
+  main:
+    name: ${{matrix.node}}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{matrix.node}}
+      - run: npm install
+      - run: npm test
+      - uses: codecov/codecov-action@v4
+    strategy:
+      matrix:
+        node:
+          - lts/hydrogen
+          - node
+name: main
+on:
+  - pull_request
+  - push

.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+*.d.ts.map
+*.d.ts
+*.log
+coverage/
+node_modules/
+yarn.lock
+!/lib/types.d.ts
+!/index.d.ts

.npmrc

@@ -0,0 +1,2 @@
+ignore-scripts=true
+package-lock=false

.prettierignore

@@ -0,0 +1,2 @@
+coverage/
+*.md

index.d.ts

@@ -0,0 +1,2 @@
+export type {Scope, Visitors} from './lib/types.js'
+export {createVisitors} from './lib/index.js'

index.js

@@ -0,0 +1,2 @@
+// Note: types exposed from `index.d.ts`.
+export {createVisitors} from './lib/index.js'

lib/index.js

@@ -0,0 +1,196 @@
+/**
+ * @import {Node, Pattern} from 'estree'
+ * @import {Scope, Visitors} from './types.js'
+ */
+
+import {ok as assert} from 'devlop'
+
+/**
+ * Create state to track what’s defined.
+ *
+ * @returns {Visitors}
+ *   State.
+ */
+export function createVisitors() {
+  /** @type {[topLevel: Scope, ...rest: Array<Scope>]} */
+  const scopes = [{block: false, defined: []}]
+
+  return {enter, exit, scopes}
+
+  /**
+   * @param {Node} node
+   *   Node.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  function enter(node) {
+    // On arrow functions, create scope, add parameters.
+    if (node.type === 'ArrowFunctionExpression') {
+      scopes.push({block: false, defined: []})
+
+      for (const parameter of node.params) {
+        definePattern(parameter, false)
+      }
+    }
+    // On block statements, create scope.
+    // Not sure why `periscopic` only does `Block`/`For`/`ForIn`/`ForOf`.
+    // I added `DoWhile`/`While` here just to be sure.
+    else if (
+      node.type === 'BlockStatement' ||
+      node.type === 'DoWhileStatement' ||
+      node.type === 'ForInStatement' ||
+      node.type === 'ForOfStatement' ||
+      node.type === 'ForStatement' ||
+      node.type === 'WhileStatement'
+    ) {
+      scopes.push({block: true, defined: []})
+    }
+
+    // On catch clauses, create scope, add param.
+    else if (node.type === 'CatchClause') {
+      scopes.push({block: true, defined: []})
+      if (node.param) definePattern(node.param, true)
+    }
+
+    // Add identifier of class declaration.
+    else if (node.type === 'ClassDeclaration') {
+      defineIdentifier(node.id.name, false)
+    }
+
+    // On function declarations, add name, create scope, add parameters.
+    else if (node.type === 'FunctionDeclaration') {
+      defineIdentifier(node.id.name, false)
+      scopes.push({block: false, defined: []})
+
+      for (const parameter of node.params) {
+        definePattern(parameter, false)
+      }
+    }
+
+    // On function expressions, add name, create scope, add parameters.
+    else if (node.type === 'FunctionExpression') {
+      if (node.id) defineIdentifier(node.id.name, false)
+      scopes.push({block: false, defined: []})
+
+      for (const parameter of node.params) {
+        definePattern(parameter, false)
+      }
+    }
+
+    // Add specifiers of import declarations.
+    else if (node.type === 'ImportDeclaration') {
+      for (const specifier of node.specifiers) {
+        defineIdentifier(specifier.local.name, false)
+      }
+    }
+
+    // Add patterns of variable declarations.
+    else if (node.type === 'VariableDeclaration') {
+      for (const declaration of node.declarations) {
+        definePattern(declaration.id, node.kind !== 'var')
+      }
+    }
+  }
+
+  /**
+   * @param {Node} node
+   *   Node.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  function exit(node) {
+    if (
+      node.type === 'ArrowFunctionExpression' ||
+      node.type === 'FunctionDeclaration' ||
+      node.type === 'FunctionExpression'
+    ) {
+      const scope = scopes.pop()
+      assert(scope, 'expected scope')
+      assert(!scope.block, 'expected non-block')
+    } else if (
+      node.type === 'BlockStatement' ||
+      node.type === 'CatchClause' ||
+      node.type === 'DoWhileStatement' ||
+      node.type === 'ForInStatement' ||
+      node.type === 'ForOfStatement' ||
+      node.type === 'ForStatement' ||
+      node.type === 'WhileStatement'
+    ) {
+      const scope = scopes.pop()
+      assert(scope, 'expected scope')
+      assert(scope.block, 'expected block')
+    }
+  }
+
+  /**
+   * Define an identifier in a scope.
+   *
+   * @param {string} id
+   * @param {boolean} block
+   * @returns {undefined}
+   */
+  function defineIdentifier(id, block) {
+    let index = scopes.length
+    /** @type {Scope | undefined} */
+    let scope
+
+    while (index--) {
+      scope = scopes[index]
+
+      if (block || !scope.block) {
+        break
+      }
+    }
+
+    assert(scope)
+    scope.defined.push(id)
+  }
+
+  /**
+   * Define a pattern in a scope.
+   *
+   * @param {Pattern} pattern
+   * @param {boolean} block
+   */
+  function definePattern(pattern, block) {
+    // `[, x]`
+    if (pattern.type === 'ArrayPattern') {
+      for (const element of pattern.elements) {
+        if (element) {
+          definePattern(element, block)
+        }
+      }
+    }
+
+    // `{x=y}`
+    else if (pattern.type === 'AssignmentPattern') {
+      definePattern(pattern.left, block)
+    }
+
+    // `x`
+    else if (pattern.type === 'Identifier') {
+      defineIdentifier(pattern.name, block)
+    }
+
+    // `{x}`
+    else if (pattern.type === 'ObjectPattern') {
+      for (const property of pattern.properties) {
+        // `{key}`, `{key = value}`, `{key: value}`
+        if (property.type === 'Property') {
+          definePattern(property.value, block)
+        }
+        // `{...x}`
+        else {
+          assert(property.type === 'RestElement')
+          definePattern(property, block)
+        }
+      }
+    }
+
+    // `...x`
+    else {
+      assert(pattern.type === 'RestElement')
+      definePattern(pattern.argument, block)
+    }
+  }
+}

lib/types.d.ts

@@ -0,0 +1,48 @@
+import type {Node} from 'estree'
+
+/**
+ * Scope.
+ */
+export interface Scope {
+  /**
+   * Whether this is a block scope or not;
+   * blocks are things made by `for` and `try` and `if`;
+   * non-blocks are functions and the top-level scope.
+   */
+  block: boolean
+  /**
+   * Identifiers that are defined in this scope.
+   */
+  defined: Array<string>
+}
+
+/**
+ * State to track what’s defined;
+ * contains `enter`, `exit` callbacks you must call and `scopes`.
+ */
+export interface Visitors {
+  /**
+   * List of scopes;
+   * the first scope is the top-level scope;
+   * the last scope is the current scope.
+   */
+  scopes: [topLevel: Scope, ...rest: Array<Scope>]
+  /**
+   * Callback you must call when entering a node.
+   *
+   * @param node
+   *   Node.
+   * @returns
+   *   Nothing.
+   */
+  enter(node: Node): undefined
+  /**
+   * Callback you must call when exiting (leaving) a node.
+   *
+   * @param node
+   *   Node.
+   * @returns
+   *   Nothing.
+   */
+  exit(node: Node): undefined
+}