casper-context 0.1.0

package/README.md

@@ -0,0 +1,253 @@
+<!--lint disable awesome-heading awesome-github awesome-toc double-link -->
+
+<p align="center">
+  <br>
+  <img width="400" src="./react-casper-context.png" alt="react casper context logo">
+  <br><br>
+</p>
+
+<h1 align="center">React Casper Context</h1>
+
+<h3 align="center">
+🚀 Declare it like a normal JavaScript variable. Use it anywhere like React Context.
+</h3>
+
+<p align="center">
+Casper Context is a Babel compile-time plugin that transforms specially prefixed variables into fully functional React Context API state — automatically.
+<br/>
+No providers. No boilerplate. No complex setup.
+<br/>
+Just declare → use → update.
+</p>
+
+<p align="center">
+<a href="https://chic-duckanoo-aa0a41.netlify.app/">
+  <img src="https://img.shields.io/badge/Live%20Demo-Open-green?style=for-the-badge" />
+</a>
+</p>
+
+<!--lint ignore-->
+
+## ✨ Quick Example
+### ✅ Declare Context Variable
+
+```jsx
+import React from 'react'
+
+function App() {
+
+  let _$_appMessage = 'Say Hi to the Casper';
+
+  return (
+    <>
+      <CasperHero />
+      <MessageBox />
+    </>
+  );
+}
+```
+
+### ✅ Use Anywhere In Component Tree
+
+```jsx
+import React from 'react'
+
+function CasperHero() {
+
+  return <h1>{_$_appMessage}</h1>;
+
+}
+
+```
+
+### ✅ Update Like Normal Variable
+
+```jsx
+import React from 'react';
+
+function MessageBox() {
+
+  const handleChange = () => {
+    _$_appMessage = 'Hi Casper';
+  } 
+
+  return (
+    <>
+
+        <button onClick={handleChange}>
+            Change
+        </button>
+
+    </>;
+}
+```
+
+That’s it. Under the hood, the plugin rewrites your code to use the native React Context API. It is 100% React-compliant at runtime.
+
+### ✨ Features
+
+- **Zero Boilerplate:** No more createContext, useContext, or wrapping components manually.
+- **Automatic Reactivity:** When a casper variable changes, all components using it re-render automatically..
+- **Scoped & Global:** Accessible in the component where it's declared and any nested child component.
+- **Native Performance:** Since it compiles to the native React Context API, there is zero overhead compared to writing Context manually.
+- **Standard Syntax:** Use familiar assignment syntax to update global state.
+
+### 📦 Installation
+
+```bash
+npm install casper-context --save-dev
+```
+### ⚙️ Setup
+
+#### 1️⃣ Add Babel Plugin
+Add it to your `.babelrc` or `babel.config.js`
+
+```json
+{
+  "plugins": ["casper-context"]
+}
+```
+#### 2️⃣ CRA Users (Important)
+Create React App does not support direct Babel modification. You must use CRACO.
+
+Install CRACO:
+
+```bash
+npm install @craco/craco
+```
+Then configure CRACO to inject the Casper Context Babel plugin in package.json
+
+```json
+  "scripts": {
+    "start": "craco start",
+    "build": "craco build",
+    "test": "craco test",
+    "eject": "react-scripts eject"
+  }
+```
+#### 3️⃣ ESLint Setup (Required)
+To avoid `undefined` variable warnings
+```js
+globals: {
+  ...require('./casper-eslint.global.js')
+}
+```
+
+### 🔧 Custom Configuration
+
+By default, the plugin identifies variables using the `_$_` prefix.
+
+```javascript
+// Default usage
+let _$_myName = 'Jhone';
+```
+###### Custom Prefix
+If you encounter naming collisions or simply prefer a different identifier, you can customize the prefix. Create a `.casperctxrc.json` file in your **project root** and specify your preferred prefix
+```json
+{
+    "prefix": "CCTX"
+}
+```
+Now, the plugin will look for your custom string instead
+```jsx
+// With custom configuration
+let CCTXmyName = 'Jhone';
+```
+
+## 📜 The Golden Rules
+
+To ensure Casper Context transforms your code correctly, please follow these core principles:
+
+### 1. Naming & Prefix
+Every Casper variable **must** start with the defined prefix (Default: `_$_`).
+* **Correct:** `let _$_userName = 'John';`
+* **Incorrect:** `let userName = 'John';`
+
+### 2. React Import Requirement
+Any file that declares, reads, or writes a Casper variable **must** import React. This is required because the compiled code relies on `React.useContext` and `React.useState`.
+* Any valid import works: 
+    * `import React from 'react';`
+    * `import * as React from 'react';`
+
+### 3. Follow React Hook Rules
+Since Casper variables are converted into Hooks under the hood, they must follow the [Rules of Hooks](https://react.dev/warnings/rules-of-hooks):
+* Only declare variables at the **top level** of your React function component.
+* Do **not** declare them inside loops, conditions, or nested functions.
+
+### 4. Global Uniqueness (Naming)
+Currently, Casper variables are treated as globally unique identifiers. You must ensure that every Casper variable name is unique across your entire project, even if they are in different components.
+* **Example:** If you have `_$_user` in `ComponentA`, do not use `_$_user` in `ComponentB`. Use `_$_adminUser` or `_$_customerUser` instead.
+
+### 5. Component-Based Context Grouping
+Contexts are grouped by the component where the variables are declared.
+* All `_$_` variables declared in the **same component** share the **same Context**.
+* To create **separate Contexts**, declare your variables in **different components**.
+
+
+
+#### Example:
+**Context A (Admin Scope):**
+```javascript
+function Admin() {
+    let _$_adminName = 'Jakie';
+    let _$_adminAge = 34;
+    // These belong to the 'Admin' Context
+}
+```
+**Context B (Customer Scope):**
+```javascript
+function Customer() {
+    let _$_customerName = 'Scot';
+    let _$_customerAge = 25;
+    // These belong to the 'Customer' Context
+}
+```
+
+## 🛠 Troubleshooting
+
+If your variables are not becoming reactive or you see errors in the console, check the following:
+
+### 1. Variables are not transforming
+* **Check the Prefix**: Ensure your variable starts exactly with your prefix (Default: `_$_`). 
+* **Declaration Keyword**: Use `let` or `var` for variables you intend to update. Using `const` will prevent you from reassigning the value later.
+* **Babel Cache**: Babel often caches transforms. Try restarting your dev server or clearing the cache (e.g., `rm -rf node_modules/.cache`).
+
+### 2. "Variable is not defined" (ESLint Errors)
+Because Casper Context injects variables at compile-time, ESLint might think they are undefined.
+* **Solution**: The plugin automatically generates a `casper-eslint.global.js` file in your root. Reference this in your `.eslintrc.js`:
+  ```javascript
+  const casperGlobals = require('./casper-eslint.global.js');
+  module.exports = {
+    globals: { ...casperGlobals }
+  };
+### 3. Changes to `.casperctxrc.json` not reflecting
+Babel reads the configuration once when the process starts.
+* **Solution**: If you change your custom prefix in `.casperctxrc.json`, you **must restart** your build tool (Vite, Webpack, or Next.js).
+### 4. Component not re-rendering
+* **Scope**: Ensure the variable is declared within a React Component or a file that is part of the Babel transformation path.
+
+* **Hooks Rules**: Remember that under the hood, this becomes a React Hook. Do not declare `_$_` variables inside nested loops or conditional if statements.
+## 📝 Debugging
+If you are still having trouble, enable debug mode in your `.casperctxrc.json`
+```json
+{
+    "prefix": "_$_",
+    "debug": true,
+    "debug_levels": ['reset','info','warn','error', 'debug', 'trace']
+}
+```
+This will generate a `.casperctx.debug.log` file in your project root, detailing exactly how the plugin is mapping your variables.
+
+### 🗺 Roadmap
+- ✅ CRA Support
+- ✅ Babel + Webpack Support
+- 🚧 Vite Integration
+- 🚧 Next.js Integration
+- 🚧 TypeScript Improvements
+- 🚧 Developer Tools Integration
+
+### 🤝 Contributing
+Contributions, suggestions, and issues are welcome.
+
+### 📜 License
+MIT License

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _plugin = _interopRequireDefault(require("./plugin"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = exports.default = _plugin.default;

package/dist/lifecycle/post.js

@@ -0,0 +1,239 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = postProcess;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _utilityHelpers = require("../utils/utilityHelpers");
+var _constants = require("../utils/constants");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * @fileoverview Environment Initialization and File Orchestration.
+ * This module is responsible for the physical creation and synchronization of 
+ * the Casper Context infrastructure, including the global context bridge and 
+ * ESLint configuration overrides.
+ */
+
+/**
+ * Path Utilities & Constants
+ * @description Leverages resolved system paths and core constants to ensure 
+ * write operations target the correct project directories.
+ */
+
+/**
+ * @module Logger
+ * @description Provides a controlled logging interface for the Babel transformation process.
+ */
+
+/**
+ * @important
+ * The following imports are critical for the library's lifecycle:
+ * - `CONTEXT_FILE_PATH`: The destination for the auto-generated React Context logic.
+ * - `ESLINT_GLOBAL_JS_PATH`: The file that prevents 'no-undef' errors for _$_ variables.
+ * - `UNICODE_UTF8`: Standard encoding used for all `fs.writeFileSync` operations.
+ */
+
+/**
+ * Generates a JavaScript module file that exports React context instances
+ * based on the registered variables in the `virtualRegistry`.
+ *
+ * This function creates or overwrites the file at `CONTEXT_FILE_PATH`, injecting
+ * `'use strict'` directives, ES module compatibility boilerplate, and context
+ * initialization code. Each registered component context is turned into a
+ * `React.createContext` with default values derived from the registry.
+ *
+ * @param {Object<string, Object>} virtualRegistry - The in-memory registry mapping
+ *   component hashes to their context metadata:
+ *   ```js
+ *   {
+ *     [componentHash]: {
+ *       ctxName: string,       // Generated context name
+ *       varNames: string[],    // List of variable names registered for this context
+ *       defaults: Record<string, any> // Default values for each variable
+ *     }
+ *   }
+ *   ```
+ *
+ * @returns {void}
+ * This function writes to the filesystem directly and does not return a value.
+ *
+ * @important
+ * - The generated module follows CommonJS export style with ES module compatibility.
+ * - All variables registered in `virtualRegistry` are included in their respective
+ *   `createContext` objects. Variables without a default value are set to `_CCTX_UNDEFINED`.
+ * - The function overwrites any existing file at `CONTEXT_FILE_PATH`.
+ * - React is imported as `_react` and used for `createContext` calls.
+ * - The `_CCTX_CMP_NAME_PREFIX` is stripped from exported context names for clarity.
+ * - Errors are silently caught; consider adding logging for debugging or dev builds.
+ * - The generated content is formatted with line breaks and indentation for readability.
+ *
+ * @example
+ * ```js
+ * const virtualRegistry = {
+ *   'abc123': {
+ *     ctxName: '_CCTX_abc123',
+ *     varNames: ['count', 'enabled'],
+ *     defaults: { count: 0, enabled: true }
+ *   }
+ * };
+ * generateContextContent(virtualRegistry);
+ * // Produces a file exporting a React context with default { count: 0, enabled: true }
+ * ```
+ */
+function generateContextContent(virtualRegistry) {
+  try {
+    _fs.default.writeFileSync(_utilityHelpers.CONTEXT_FILE_PATH, _constants._CCTX_EMPTY, _constants.UNICODE_UTF8);
+    let contextNames = [];
+    let content = `'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n`;
+    if (Object.keys(virtualRegistry).length === 0) return;
+    Object.values(virtualRegistry).forEach(entry => {
+      if (!entry.ctxName) return;
+      contextNames.push(entry.ctxName.replace(_constants._CCTX_CMP_NAME_PREFIX, _constants._CCTX_EMPTY));
+    });
+    content += `exports.${contextNames.join(' = exports.')} = void 0;\n`;
+    content += `var _react = require('react');\n`;
+    Object.values(virtualRegistry).forEach(entry => {
+      if (!entry.ctxName) return;
+      const {
+        ctxName,
+        varNames,
+        defaults
+      } = entry;
+      const defaultObjProps = varNames.map(name => {
+        const val = defaults[name] !== undefined ? JSON.stringify(defaults[name]) : _constants._CCTX_UNDEFINED;
+        return `  ${name}: ${val}`;
+      }).join(',\n');
+      content += `const ${ctxName.replace(_constants._CCTX_CMP_NAME_PREFIX, _constants._CCTX_EMPTY)} = exports.${ctxName.replace(_constants._CCTX_CMP_NAME_PREFIX, _constants._CCTX_EMPTY)} = /*#__PURE__*/(0, _react.createContext)({\n${defaultObjProps}\n});\n`;
+    });
+    _fs.default.writeFileSync(_utilityHelpers.CONTEXT_FILE_PATH, content, _constants.UNICODE_UTF8);
+  } catch (e) {
+    (0, _utilityHelpers.log)('error', '[::generateContextContent::]', e.message);
+  }
+}
+
+/**
+ * Generates or updates the ESLint global variables configuration file
+ * based on the current virtual registry.
+ *
+ * This function reads all variable names registered in `virtualRegistry`
+ * and writes them as read-only globals in a JavaScript module (`ESLINT_GLOBAL_JS_PATH`).
+ * It compares the newly generated content with the existing file and only
+ * overwrites if changes are detected. Finally, it updates the modification
+ * timestamp of the ESLint configuration file to trigger linting updates if needed.
+ *
+ * @param {Object<string, Object>} virtualRegistry - The in-memory registry of component
+ *   variables. Each entry should contain:
+ *   ```js
+ *   {
+ *     varNames: string[],   // List of variable names for the component/context
+ *     ctxName?: string,     // Optional context name
+ *     defaults?: Record<string, any> // Optional default values
+ *   }
+ *   ```
+ * @param {Object<string, Object>} [prevVirtualRegistrySnap] - Optional snapshot of
+ *   the previous virtual registry state. Currently unused, but can be used
+ *   to detect changes or optimize writes.
+ *
+ * @returns {void}
+ * Writes or updates the ESLint global JS file on disk and updates the
+ * corresponding ESLint configuration file's timestamps.
+ *
+ * @important
+ * - All variables are marked as read-only in the ESLint globals (`CASPER_READ_ONLY_TYPE`).
+ * - File writes are **atomic**: the target file is cleared before writing new content.
+ * - If no variables exist in the registry, the function exits early without writing.
+ * - Errors are silently caught; consider adding logging for development.
+ * - Changes are only applied if the content differs from the current file, avoiding
+ *   unnecessary filesystem writes.
+ * - The file starts with a comment indicating it is auto-generated by CasperContext.
+ *
+ * @example
+ * ```js
+ * const virtualRegistry = {
+ *   'abc123': {
+ *     varNames: ['count', 'enabled'],
+ *     ctxName: '_CCTX_abc123',
+ *     defaults: { count: 0, enabled: true }
+ *   }
+ * };
+ * generateLintGlobalJS(virtualRegistry);
+ * // Writes ESLint globals file:
+ * // module.exports = {
+ * //   "count": "readonly",
+ * //   "enabled": "readonly"
+ * // };
+ * ```
+ */
+function generateLintGlobalJS(virtualRegistry, prevVirtualRegistrySnap) {
+  try {
+    if (Object.keys(virtualRegistry).length === 0) return;
+    const currentCnt = _fs.default.readFileSync(_utilityHelpers.ESLINT_GLOBAL_JS_PATH, _constants.UNICODE_UTF8);
+    const content = Object.values(virtualRegistry).flatMap(entry => entry.varNames || []).map(name => `  "${name}": "${_constants.CASPER_READ_ONLY_TYPE}"`).join(',\n');
+    const fileContent = `// ****** generated by CasperContext ******
+module.exports = {\n${content}\n};\n`;
+    if (currentCnt !== fileContent) {
+      _fs.default.writeFileSync(_utilityHelpers.ESLINT_GLOBAL_JS_PATH, _constants._CCTX_EMPTY, _constants.UNICODE_UTF8);
+      _fs.default.writeFileSync(_utilityHelpers.ESLINT_GLOBAL_JS_PATH, fileContent, _constants.UNICODE_UTF8);
+      _fs.default.utimesSync(_path.default.join(process.cwd(), _constants.ESLINT_RC_FILE), new Date(), new Date());
+    }
+  } catch (e) {
+    (0, _utilityHelpers.log)('error', '[::generateLintGlobalJS::]', e.message);
+  }
+}
+
+/**
+ * Performs post-processing steps after AST transformations on a file.
+ *
+ * This function generates or updates auxiliary files based on the current
+ * state of the virtual registry. Specifically:
+ * 1. `generateContextContent` – creates the module exporting React context
+ *    instances with default values.
+ * 2. `generateLintGlobalJS` – updates the ESLint global variables file
+ *    with read-only entries for all registered variables.
+ *
+ * @param {string} file - The path of the file that was processed. Currently unused,
+ *   but provided for future enhancements or logging purposes.
+ * @param {Object} t - Babel types helper (`@babel/types`) used in AST operations.
+ * @param {Object<string, Object>} virtualRegistry - The in-memory registry
+ *   of component/context variables, structured as:
+ *   ```js
+ *   {
+ *     [componentHash]: {
+ *       ctxName: string,
+ *       varNames: string[],
+ *       defaults: Record<string, any>
+ *     }
+ *   }
+ *   ```
+ * @param {Object<string, Object>} [prevVirtualRegistrySnap] - Optional snapshot
+ *   of the previous virtual registry state, used to detect changes and optimize writes.
+ *
+ * @returns {void}
+ * This function does not return a value; its effect is to update filesystem
+ * files (`CONTEXT_FILE_PATH` and `ESLINT_GLOBAL_JS_PATH`) based on the registry.
+ *
+ * @important
+ * - Errors are silently caught; consider adding logging for debugging.
+ * - Both `generateContextContent` and `generateLintGlobalJS` may overwrite
+ *   existing files.
+ * - The `file` parameter is not currently used internally but is included
+ *   for potential future processing logic.
+ *
+ * @example
+ * ```js
+ * import postProcess from './postProcess';
+ *
+ * postProcess('src/App.js', t, virtualRegistry, prevVirtualRegistrySnap);
+ * // Generates context and ESLint globals files based on the current registry
+ * ```
+ */
+function postProcess(file, t, virtualRegistry, prevVirtualRegistrySnap) {
+  try {
+    generateContextContent(virtualRegistry);
+    generateLintGlobalJS(virtualRegistry, prevVirtualRegistrySnap);
+  } catch (e) {
+    (0, _utilityHelpers.log)('error', '[::postProcess::]', e.message);
+  }
+}

package/dist/lifecycle/pre.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = preProcess;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _utilityHelpers = require("../utils/utilityHelpers");
+var _constants = require("../utils/constants");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * @fileoverview File System Orchestration for Casper Context.
+ * This module manages the lifecycle of the generated context files, handling
+ * the reading, writing, and directory verification required to sync the 
+ * Babel transformation with the physical project structure.
+ */
+
+/**
+ * Path & State Dependencies
+ * @description 
+ * - CONTEXT_FILE_PATH: The absolute resolved destination for the generated React Context.
+ * - _CCTX_EMPTY: Used as a safe fallback or initializer for file content buffers.
+ */
+
+/**
+ * @module Logger
+ * @description Provides a controlled logging interface for the Babel transformation process.
+ */
+
+/**
+ * @important
+ * All file operations in this module should prioritize synchronous methods (`fs.writeFileSync`, etc.)
+ * during the Babel build-step to ensure the file system is in sync before the 
+ * bundling process (Webpack/Vite) begins.
+ */
+
+/**
+ * Initializes the scope context file and directory for Casper context tracking.
+ *
+ * This function ensures that the directory containing the context file exists,
+ * and then creates an empty context file at `CONTEXT_FILE_PATH` if it does not
+ * already exist. It is intended to prepare the filesystem for storing generated
+ * React context instances and related metadata.
+ *
+ * @returns {void}
+ * This function does not return a value; its effect is purely filesystem-based.
+ *
+ * @important
+ * - Uses `fs.mkdirSync` with `{ recursive: true }` to create parent directories as needed.
+ * - Writes an empty file at `CONTEXT_FILE_PATH` with the `{ flag: 'wx' }` option,
+ *   which means the file is only created if it does not already exist.
+ * - Errors are silently caught, so existing files or directories will not cause failures.
+ * - Intended to be called before processing files (`preProcess`) or generating context content.
+ *
+ * @example
+ * ```js
+ * createScopeContext();
+ * // Ensures the context directory and empty context file exist
+ * ```
+ */
+function createScopeContext() {
+  try {
+    const dirPath = _path.default.dirname(_utilityHelpers.CONTEXT_FILE_PATH);
+    _fs.default.mkdirSync(dirPath, {
+      recursive: true
+    });
+    _fs.default.writeFileSync(_utilityHelpers.CONTEXT_FILE_PATH, _constants._CCTX_EMPTY, {
+      flag: 'wx'
+    });
+  } catch (e) {
+    (0, _utilityHelpers.log)('error', '[::createScopeContext::]', e.message);
+  }
+}
+
+/**
+ * Performs pre-processing steps before AST transformations on a file.
+ *
+ * This function sets up the necessary runtime or plugin context before
+ * any file transformations occur. Currently, it calls `createScopeContext()`
+ * to initialize the global scope or virtual registry for tracking component
+ * variables and contexts.
+ *
+ * @param {string} file - The path of the file that will be processed. Currently unused,
+ *   but provided for future enhancements or logging purposes.
+ * @param {Object} t - Babel types helper (`@babel/types`) used for AST operations.
+ *
+ * @returns {void}
+ * This function does not return a value; its effect is to initialize internal
+ * context structures for later processing.
+ *
+ * @important
+ * - Errors are silently caught; consider adding logging for debugging.
+ * - Currently, the function only calls `createScopeContext()`, but can be
+ *   extended for additional pre-processing tasks.
+ * - The `file` parameter is not used internally but may be relevant in
+ *   future versions for file-specific setup.
+ *
+ * @example
+ * ```js
+ * import preProcess from './preProcess';
+ *
+ * preProcess('src/App.js', t);
+ * // Initializes context for virtual registry and component tracking
+ * ```
+ */
+function preProcess(file, t) {
+  try {
+    createScopeContext();
+  } catch (e) {
+    (0, _utilityHelpers.log)('error', '[::preProcess::]', e.message);
+  }
+}

package/dist/plugin.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _constants = require("./utils/constants");
+var _pre = _interopRequireDefault(require("./lifecycle/pre"));
+var _post = _interopRequireDefault(require("./lifecycle/post"));
+var _VariableDeclaration = _interopRequireDefault(require("./visitors/VariableDeclaration"));
+var _AssignmentExpression = _interopRequireDefault(require("./visitors/AssignmentExpression"));
+var _Identifier = _interopRequireDefault(require("./visitors/Identifier"));
+var _Program = require("./visitors/Program");
+var _FunctionDeclaration = require("./visitors/FunctionDeclaration");
+var _utilityHelpers = require("./utils/utilityHelpers");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const virtualRegistry = {};
+const prevVirtualRegistrySnap = {};
+function _default({
+  types: t
+}) {
+  const config = (0, _utilityHelpers.readCasperConfig)();
+  const seen = new WeakSet();
+  return {
+    name: _constants.PLUGIN_NAME,
+    pre(file) {
+      _pre.default.call(this, file, t);
+    },
+    visitor: {
+      Program: {
+        enter(path, state) {
+          _Program.programEnter.call(this, path, state, t, virtualRegistry, config);
+        },
+        exit(path, state) {
+          _Program.programExit.call(this, path, state, t);
+        }
+      },
+      VariableDeclarator(path, state) {
+        _VariableDeclaration.default.call(this, path, state, t, virtualRegistry);
+      },
+      AssignmentExpression(path, state) {
+        _AssignmentExpression.default.call(this, path, state, t, virtualRegistry);
+      },
+      Identifier(path, state) {
+        _Identifier.default.call(this, path, state, t, seen, virtualRegistry);
+      },
+      FunctionDeclaration: {
+        exit(path, state) {
+          _FunctionDeclaration.functionDeclarationExit.call(this, path, state, t, virtualRegistry);
+        }
+      }
+    },
+    post(file) {
+      _post.default.call(this, file, t, virtualRegistry, prevVirtualRegistrySnap);
+    }
+  };
+}

package/dist/transforms/autoContextTransform.js

@@ -0,0 +1 @@
+"use strict";

package/dist/transforms/contextTransform.js

@@ -0,0 +1 @@
+"use strict";

package/dist/transforms/stateTransform.js

@@ -0,0 +1 @@
+"use strict";

package/dist/types/plugin.d.js

@@ -0,0 +1 @@
+"use strict";