@react-router/dev 0.0.0-experimental-9c1812606 → 0.0.0-experimental-3278f3ca6

package/dist/vite/remove-exports.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-9c1812606
+ * @react-router/dev v0.0.0-experimental-3278f3ca6
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -12,267 +12,137 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var babelDeadCodeElimination = require('babel-dead-code-elimination');
 var babel = require('./babel.js');
-var parser = require('@babel/parser');
-var t = require('@babel/types');
 
-function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
+const removeExports = (ast, exportsToRemove) => {
+  let previouslyReferencedIdentifiers = babelDeadCodeElimination.findReferencedIdentifiers(ast);
+  let exportsFiltered = false;
+  let markedForRemoval = new Set();
+  babel.traverse(ast, {
+    ExportDeclaration(path) {
+      // export { foo };
+      // export { bar } from "./module";
+      if (path.node.type === "ExportNamedDeclaration") {
+        var _path$node$declaratio, _path$node$declaratio2, _path$node$declaratio3;
+        if (path.node.specifiers.length) {
+          path.node.specifiers = path.node.specifiers.filter(specifier => {
+            // Filter out individual specifiers
+            if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier") {
+              if (exportsToRemove.includes(specifier.exported.name)) {
+                exportsFiltered = true;
+                return false;
+              }
             }
-        });
-    }
-    n["default"] = e;
-    return Object.freeze(n);
-}
-
-var t__namespace = /*#__PURE__*/_interopNamespace(t);
-
-function getIdentifier(path) {
-  let parentPath = path.parentPath;
-  if (parentPath.type === "VariableDeclarator") {
-    let variablePath = parentPath;
-    let name = variablePath.get("id");
-    return name.node.type === "Identifier" ? name : null;
-  }
-  if (parentPath.type === "AssignmentExpression") {
-    let variablePath = parentPath;
-    let name = variablePath.get("left");
-    return name.node.type === "Identifier" ? name : null;
-  }
-  if (path.node.type === "ArrowFunctionExpression") {
-    return null;
-  }
-  return path.node.id && path.node.id.type === "Identifier" ? path.get("id") : null;
-}
-function isIdentifierReferenced(ident) {
-  let binding = ident.scope.getBinding(ident.node.name);
-  if (binding !== null && binding !== void 0 && binding.referenced) {
-    // Functions can reference themselves, so we need to check if there's a
-    // binding outside the function scope or not.
-    if (binding.path.type === "FunctionDeclaration") {
-      return !binding.constantViolations.concat(binding.referencePaths)
-      // Check that every reference is contained within the function:
-      .every(ref => ref.findParent(parent => parent === (binding === null || binding === void 0 ? void 0 : binding.path)));
-    }
-    return true;
-  }
-  return false;
-}
-const removeExports = (source, exportsToRemove, generateOptions = {}) => {
-  let document = parser.parse(source, {
-    sourceType: "module"
-  });
-  let referencedIdentifiers = new Set();
-  let removedExports = new Set();
-  let markImport = path => {
-    let local = path.get("local");
-    if (isIdentifierReferenced(local)) {
-      referencedIdentifiers.add(local);
-    }
-  };
-  let markFunction = path => {
-    let identifier = getIdentifier(path);
-    if (identifier !== null && identifier !== void 0 && identifier.node && isIdentifierReferenced(identifier)) {
-      referencedIdentifiers.add(identifier);
-    }
-  };
-  babel.traverse(document, {
-    VariableDeclarator(variablePath) {
-      if (variablePath.node.id.type === "Identifier") {
-        let local = variablePath.get("id");
-        if (isIdentifierReferenced(local)) {
-          referencedIdentifiers.add(local);
-        }
-      } else if (variablePath.node.id.type === "ObjectPattern") {
-        let pattern = variablePath.get("id");
-        let properties = pattern.get("properties");
-        properties.forEach(p => {
-          let local = p.get(p.node.type === "ObjectProperty" ? "value" : p.node.type === "RestElement" ? "argument" : function () {
-            throw new Error("invariant");
-          }());
-          if (isIdentifierReferenced(local)) {
-            referencedIdentifiers.add(local);
-          }
-        });
-      } else if (variablePath.node.id.type === "ArrayPattern") {
-        let pattern = variablePath.get("id");
-        let elements = pattern.get("elements");
-        elements.forEach(element => {
-          var _element$node, _element$node2;
-          let local;
-          if (((_element$node = element.node) === null || _element$node === void 0 ? void 0 : _element$node.type) === "Identifier") {
-            local = element;
-          } else if (((_element$node2 = element.node) === null || _element$node2 === void 0 ? void 0 : _element$node2.type) === "RestElement") {
-            local = element.get("argument");
-          } else {
-            return;
-          }
-          if (isIdentifierReferenced(local)) {
-            referencedIdentifiers.add(local);
-          }
-        });
-      }
-    },
-    FunctionDeclaration: markFunction,
-    FunctionExpression: markFunction,
-    ArrowFunctionExpression: markFunction,
-    ImportSpecifier: markImport,
-    ImportDefaultSpecifier: markImport,
-    ImportNamespaceSpecifier: markImport,
-    ExportNamedDeclaration(path) {
-      let shouldRemove = false;
-      // Handle re-exports: export { preload } from './foo'
-      path.node.specifiers = path.node.specifiers.filter(spec => {
-        if (spec.exported.type !== "Identifier") {
-          return true;
-        }
-        let {
-          name
-        } = spec.exported;
-        for (let namedExport of exportsToRemove) {
-          if (name === namedExport) {
-            removedExports.add(namedExport);
-            return false;
+            return true;
+          });
+          // Remove the entire export statement if all specifiers were removed
+          if (path.node.specifiers.length === 0) {
+            markedForRemoval.add(path);
           }
         }
-        return true;
-      });
-      let {
-        declaration
-      } = path.node;
-      // When no re-exports are left, remove the path
-      if (!declaration && path.node.specifiers.length === 0) {
-        shouldRemove = true;
-      }
-      if (declaration && declaration.type === "VariableDeclaration") {
-        declaration.declarations = declaration.declarations.filter(declarator => {
-          for (let name of exportsToRemove) {
-            if (declarator.id.name === name) {
-              removedExports.add(name);
+        // export const foo = ...;
+        // export const [ foo ] = ...;
+        if (((_path$node$declaratio = path.node.declaration) === null || _path$node$declaratio === void 0 ? void 0 : _path$node$declaratio.type) === "VariableDeclaration") {
+          let declaration = path.node.declaration;
+          declaration.declarations = declaration.declarations.filter(declaration => {
+            // export const foo = ...;
+            // export const foo = ..., bar = ...;
+            if (declaration.id.type === "Identifier" && exportsToRemove.includes(declaration.id.name)) {
+              // Filter out individual variables
+              exportsFiltered = true;
               return false;
             }
+            // export const [ foo ] = ...;
+            // export const { foo } = ...;
+            if (declaration.id.type === "ArrayPattern" || declaration.id.type === "ObjectPattern") {
+              // NOTE: These exports cannot be safely removed, so instead we
+              // validate them to ensure that any exports that are intended to
+              // be removed are not present
+              validateDestructuredExports(declaration.id, exportsToRemove);
+            }
+            return true;
+          });
+          // Remove the entire export statement if all variables were removed
+          if (declaration.declarations.length === 0) {
+            markedForRemoval.add(path);
           }
-          return true;
-        });
-        if (declaration.declarations.length === 0) {
-          shouldRemove = true;
         }
-      }
-      if (declaration && declaration.type === "FunctionDeclaration") {
-        for (let name of exportsToRemove) {
-          var _declaration$id;
-          if (((_declaration$id = declaration.id) === null || _declaration$id === void 0 ? void 0 : _declaration$id.name) === name) {
-            shouldRemove = true;
-            removedExports.add(name);
+        // export function foo() {}
+        if (((_path$node$declaratio2 = path.node.declaration) === null || _path$node$declaratio2 === void 0 ? void 0 : _path$node$declaratio2.type) === "FunctionDeclaration") {
+          let id = path.node.declaration.id;
+          if (id && exportsToRemove.includes(id.name)) {
+            markedForRemoval.add(path);
+          }
+        }
+        // export class Foo() {}
+        if (((_path$node$declaratio3 = path.node.declaration) === null || _path$node$declaratio3 === void 0 ? void 0 : _path$node$declaratio3.type) === "ClassDeclaration") {
+          let id = path.node.declaration.id;
+          if (id && exportsToRemove.includes(id.name)) {
+            markedForRemoval.add(path);
           }
         }
       }
-      if (shouldRemove) {
-        path.remove();
+      // export default ...;
+      if (path.node.type === "ExportDefaultDeclaration" && exportsToRemove.includes("default")) {
+        markedForRemoval.add(path);
       }
     }
   });
-  if (removedExports.size === 0) {
-    // No server-specific exports found so there's
-    // no need to remove unused references
-    return babel.generate(document, generateOptions);
+  if (markedForRemoval.size > 0 || exportsFiltered) {
+    for (let path of markedForRemoval) {
+      path.remove();
+    }
+    // Run dead code elimination on any newly unreferenced identifiers
+    babelDeadCodeElimination.deadCodeElimination(ast, previouslyReferencedIdentifiers);
   }
-  let referencesRemovedInThisPass;
-  let sweepFunction = path => {
-    let identifier = getIdentifier(path);
-    if (identifier !== null && identifier !== void 0 && identifier.node && referencedIdentifiers.has(identifier) && !isIdentifierReferenced(identifier)) {
-      ++referencesRemovedInThisPass;
-      if (t__namespace.isAssignmentExpression(path.parentPath.node) || t__namespace.isVariableDeclarator(path.parentPath.node)) {
-        path.parentPath.remove();
-      } else {
-        path.remove();
+};
+function validateDestructuredExports(id, exportsToRemove) {
+  if (id.type === "ArrayPattern") {
+    for (let element of id.elements) {
+      if (!element) {
+        continue;
       }
-    }
-  };
-  let sweepImport = path => {
-    let local = path.get("local");
-    if (referencedIdentifiers.has(local) && !isIdentifierReferenced(local)) {
-      ++referencesRemovedInThisPass;
-      path.remove();
-      if (path.parent.specifiers.length === 0) {
-        path.parentPath.remove();
+      // [ foo ]
+      if (element.type === "Identifier" && exportsToRemove.includes(element.name)) {
+        throw invalidDestructureError(element.name);
+      }
+      // [ ...foo ]
+      if (element.type === "RestElement" && element.argument.type === "Identifier" && exportsToRemove.includes(element.argument.name)) {
+        throw invalidDestructureError(element.argument.name);
+      }
+      // [ [...] ]
+      // [ {...} ]
+      if (element.type === "ArrayPattern" || element.type === "ObjectPattern") {
+        validateDestructuredExports(element, exportsToRemove);
       }
     }
-  };
-  // Traverse again to remove unused references. This happens at least once,
-  // then repeats until no more references are removed.
-  do {
-    referencesRemovedInThisPass = 0;
-    babel.traverse(document, {
-      Program(path) {
-        path.scope.crawl();
-      },
-      // eslint-disable-next-line no-loop-func
-      VariableDeclarator(variablePath) {
-        if (variablePath.node.id.type === "Identifier") {
-          let local = variablePath.get("id");
-          if (referencedIdentifiers.has(local) && !isIdentifierReferenced(local)) {
-            ++referencesRemovedInThisPass;
-            variablePath.remove();
-          }
-        } else if (variablePath.node.id.type === "ObjectPattern") {
-          let pattern = variablePath.get("id");
-          let beforeCount = referencesRemovedInThisPass;
-          let properties = pattern.get("properties");
-          properties.forEach(property => {
-            let local = property.get(property.node.type === "ObjectProperty" ? "value" : property.node.type === "RestElement" ? "argument" : function () {
-              throw new Error("invariant");
-            }());
-            if (referencedIdentifiers.has(local) && !isIdentifierReferenced(local)) {
-              ++referencesRemovedInThisPass;
-              property.remove();
-            }
-          });
-          if (beforeCount !== referencesRemovedInThisPass && pattern.get("properties").length < 1) {
-            variablePath.remove();
-          }
-        } else if (variablePath.node.id.type === "ArrayPattern") {
-          let pattern = variablePath.get("id");
-          let beforeCount = referencesRemovedInThisPass;
-          let elements = pattern.get("elements");
-          elements.forEach(e => {
-            var _e$node, _e$node2;
-            let local;
-            if (((_e$node = e.node) === null || _e$node === void 0 ? void 0 : _e$node.type) === "Identifier") {
-              local = e;
-            } else if (((_e$node2 = e.node) === null || _e$node2 === void 0 ? void 0 : _e$node2.type) === "RestElement") {
-              local = e.get("argument");
-            } else {
-              return;
-            }
-            if (referencedIdentifiers.has(local) && !isIdentifierReferenced(local)) {
-              ++referencesRemovedInThisPass;
-              e.remove();
-            }
-          });
-          if (beforeCount !== referencesRemovedInThisPass && pattern.get("elements").length < 1) {
-            variablePath.remove();
-          }
+  }
+  if (id.type === "ObjectPattern") {
+    for (let property of id.properties) {
+      if (!property) {
+        continue;
+      }
+      if (property.type === "ObjectProperty" && property.key.type === "Identifier") {
+        // { foo }
+        if (property.value.type === "Identifier" && exportsToRemove.includes(property.value.name)) {
+          throw invalidDestructureError(property.value.name);
         }
-      },
-      FunctionDeclaration: sweepFunction,
-      FunctionExpression: sweepFunction,
-      ArrowFunctionExpression: sweepFunction,
-      ImportSpecifier: sweepImport,
-      ImportDefaultSpecifier: sweepImport,
-      ImportNamespaceSpecifier: sweepImport
-    });
-  } while (referencesRemovedInThisPass);
-  return babel.generate(document, generateOptions);
-};
+        // { foo: [...] }
+        // { foo: {...} }
+        if (property.value.type === "ArrayPattern" || property.value.type === "ObjectPattern") {
+          validateDestructuredExports(property.value, exportsToRemove);
+        }
+      }
+      // { ...foo }
+      if (property.type === "RestElement" && property.argument.type === "Identifier" && exportsToRemove.includes(property.argument.name)) {
+        throw invalidDestructureError(property.argument.name);
+      }
+    }
+  }
+}
+function invalidDestructureError(name) {
+  return new Error(`Cannot remove destructured export "${name}"`);
+}
 
 exports.removeExports = removeExports;

package/dist/vite/resolve-file-url.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-9c1812606
+ * @react-router/dev v0.0.0-experimental-3278f3ca6
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/vite/static/refresh-utils.cjs

@@ -60,7 +60,13 @@ const enqueueUpdate = debounce(async () => {
     window.__reactRouterRouteModuleUpdates.clear();
   }
 
-  await revalidate();
+  try {
+    window.__remixHdrActive = true;
+    await __remixRouter.revalidate();
+  } finally {
+    window.__remixHdrActive = false;
+  }
+
   if (manifest) {
     Object.assign(window.__remixManifest, manifest);
   }
@@ -145,31 +151,6 @@ function __hmr_import(module) {
 const routeUpdates = new Map();
 window.__reactRouterRouteModuleUpdates = new Map();
 
-async function revalidate() {
-  let { promise, resolve } = channel();
-  let unsub = __remixRouter.subscribe((state) => {
-    if (state.revalidation === "idle") {
-      unsub();
-      // Ensure RouterProvider setState has flushed before re-rendering
-      resolve();
-    }
-  });
-  window.__remixRevalidation = (window.__remixRevalidation || 0) + 1;
-  __remixRouter.revalidate();
-  return promise;
-}
-
-function channel() {
-  let resolve;
-  let reject;
-
-  let promise = new Promise((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-  });
-  return { promise, resolve, reject };
-}
-
 import.meta.hot.on("react-router:hmr", async ({ route }) => {
   window.__remixClearCriticalCss();
 

package/dist/vite/styles.d.ts

@@ -1,11 +1,12 @@
 import type { ServerBuild } from "react-router";
 import type { ViteDevServer } from "vite";
-import type { ResolvedVitePluginConfig } from "../config";
+import type { ResolvedReactRouterConfig } from "./config";
 export declare const isCssModulesFile: (file: string) => boolean;
+export declare const isCssUrlWithoutSideEffects: (url: string) => boolean;
 export declare const getStylesForUrl: ({ viteDevServer, rootDirectory, reactRouterConfig, entryClientFilePath, cssModulesManifest, build, url, }: {
     viteDevServer: ViteDevServer;
     rootDirectory: string;
-    reactRouterConfig: Pick<ResolvedVitePluginConfig, "appDirectory" | "routes">;
+    reactRouterConfig: Pick<ResolvedReactRouterConfig, "appDirectory" | "routes">;
     entryClientFilePath: string;
     cssModulesManifest: Record<string, string>;
     build: ServerBuild;

package/dist/vite/styles.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-9c1812606
+ * @react-router/dev v0.0.0-experimental-3278f3ca6
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -44,6 +44,26 @@ const cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\
 const cssModulesRegExp = new RegExp(`\\.module${cssFileRegExp.source}`);
 const isCssFile = file => cssFileRegExp.test(file);
 const isCssModulesFile = file => cssModulesRegExp.test(file);
+// https://vitejs.dev/guide/features#disabling-css-injection-into-the-page
+// https://github.com/vitejs/vite/blob/561b940f6f963fbb78058a6e23b4adad53a2edb9/packages/vite/src/node/plugins/css.ts#L194
+// https://vitejs.dev/guide/features#static-assets
+// https://github.com/vitejs/vite/blob/561b940f6f963fbb78058a6e23b4adad53a2edb9/packages/vite/src/node/utils.ts#L309-L310
+const cssUrlParamsWithoutSideEffects = ["url", "inline", "raw", "inline-css"];
+const isCssUrlWithoutSideEffects = url => {
+  let queryString = url.split("?")[1];
+  if (!queryString) {
+    return false;
+  }
+  let params = new URLSearchParams(queryString);
+  for (let paramWithoutSideEffects of cssUrlParamsWithoutSideEffects) {
+    if (
+    // Parameter is blank and not explicitly set, i.e. "?url", not "?url="
+    params.get(paramWithoutSideEffects) === "" && !url.includes(`?${paramWithoutSideEffects}=`) && !url.includes(`&${paramWithoutSideEffects}=`)) {
+      return true;
+    }
+  }
+  return false;
+};
 const getStylesForFiles = async ({
   viteDevServer,
   rootDirectory,
@@ -79,7 +99,7 @@ const getStylesForFiles = async ({
     console.error(err);
   }
   for (let dep of deps) {
-    if (dep.file && isCssFile(dep.file) && !dep.url.endsWith("?url") // Ignore styles that resolved as URLs, otherwise we'll end up injecting URLs into the style tag contents
+    if (dep.file && isCssFile(dep.file) && !isCssUrlWithoutSideEffects(dep.url) // Ignore styles that resolved as URLs, inline or raw. These shouldn't get injected.
     ) {
       try {
         let css = isCssModulesFile(dep.file) ? cssModulesManifest[dep.file] : (await viteDevServer.ssrLoadModule(dep.url)).default;
@@ -174,3 +194,4 @@ const getStylesForUrl = async ({
 
 exports.getStylesForUrl = getStylesForUrl;
 exports.isCssModulesFile = isCssModulesFile;
+exports.isCssUrlWithoutSideEffects = isCssUrlWithoutSideEffects;

package/dist/vite/vmod.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-9c1812606
+ * @react-router/dev v0.0.0-experimental-3278f3ca6
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/vite/with-props.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "vite";
+import type { Babel, ParseResult } from "./babel";
+export declare const plugin: Plugin;
+export declare const transform: (ast: ParseResult<Babel.File>) => void;

package/dist/vite/with-props.js

@@ -0,0 +1,151 @@
+/**
+ * @react-router/dev v0.0.0-experimental-3278f3ca6
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dedent = require('dedent');
+var babel = require('./babel.js');
+var vmod = require('./vmod.js');
+var t = require('@babel/types');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var dedent__default = /*#__PURE__*/_interopDefaultLegacy(dedent);
+var t__namespace = /*#__PURE__*/_interopNamespace(t);
+
+const vmodId = vmod.id("with-props");
+const NAMED_COMPONENT_EXPORTS = ["HydrateFallback", "ErrorBoundary"];
+const plugin = {
+  name: "react-router-with-props",
+  enforce: "pre",
+  resolveId(id) {
+    if (id === vmodId) return vmod.resolve(vmodId);
+  },
+  async load(id) {
+    if (id !== vmod.resolve(vmodId)) return;
+    return dedent__default["default"]`
+      import { createElement as h } from "react";
+      import { useActionData, useLoaderData, useParams } from "react-router";
+
+      export function withComponentProps(Component) {
+        return function Wrapped() {
+          const props = {
+            params: useParams(),
+            loaderData: useLoaderData(),
+            actionData: useActionData(),
+          };
+          return h(Component, props);
+        };
+      }
+
+      export function withHydrateFallbackProps(HydrateFallback) {
+        return function Wrapped() {
+          const props = {
+            params: useParams(),
+          };
+          return h(HydrateFallback, props);
+        };
+      }
+
+      export function withErrorBoundaryProps(ErrorBoundary) {
+        return function Wrapped() {
+          const props = {
+            params: useParams(),
+            loaderData: useLoaderData(),
+            actionData: useActionData(),
+          };
+          return h(ErrorBoundary, props);
+        };
+      }
+    `;
+  }
+};
+const transform = ast => {
+  const hocs = [];
+  function getHocUid(path, hocName) {
+    const uid = path.scope.generateUidIdentifier(hocName);
+    hocs.push([hocName, uid]);
+    return uid;
+  }
+  babel.traverse(ast, {
+    ExportDeclaration(path) {
+      if (path.isExportDefaultDeclaration()) {
+        const declaration = path.get("declaration");
+        // prettier-ignore
+        const expr = declaration.isExpression() ? declaration.node : declaration.isFunctionDeclaration() ? toFunctionExpression(declaration.node) : undefined;
+        if (expr) {
+          const uid = getHocUid(path, "withComponentProps");
+          declaration.replaceWith(t__namespace.callExpression(uid, [expr]));
+        }
+        return;
+      }
+      if (path.isExportNamedDeclaration()) {
+        const decl = path.get("declaration");
+        if (decl.isVariableDeclaration()) {
+          decl.get("declarations").forEach(varDeclarator => {
+            const id = varDeclarator.get("id");
+            const init = varDeclarator.get("init");
+            const expr = init.node;
+            if (!expr) return;
+            if (!id.isIdentifier()) return;
+            const {
+              name
+            } = id.node;
+            if (!NAMED_COMPONENT_EXPORTS.includes(name)) return;
+            const uid = getHocUid(path, `with${name}Props`);
+            init.replaceWith(t__namespace.callExpression(uid, [expr]));
+          });
+          return;
+        }
+        if (decl.isFunctionDeclaration()) {
+          const {
+            id
+          } = decl.node;
+          if (!id) return;
+          const {
+            name
+          } = id;
+          if (!NAMED_COMPONENT_EXPORTS.includes(name)) return;
+          const uid = getHocUid(path, `with${name}Props`);
+          decl.replaceWith(t__namespace.variableDeclaration("const", [t__namespace.variableDeclarator(t__namespace.identifier(name), t__namespace.callExpression(uid, [toFunctionExpression(decl.node)]))]));
+        }
+      }
+    }
+  });
+  if (hocs.length > 0) {
+    ast.program.body.unshift(t__namespace.importDeclaration(hocs.map(([name, identifier]) => t__namespace.importSpecifier(identifier, t__namespace.identifier(name))), t__namespace.stringLiteral(vmodId)));
+  }
+};
+function toFunctionExpression(decl) {
+  return t__namespace.functionExpression(decl.id, decl.params, decl.body, decl.generator, decl.async);
+}
+
+exports.plugin = plugin;
+exports.transform = transform;