@tanstack/router-vite-plugin 1.39.3 → 1.39.4

package/dist/esm/eliminateUnreferencedIdentifiers.js

@@ -1,132 +0,0 @@
-import * as t from "@babel/types";
-const eliminateUnreferencedIdentifiers = (programPath, refs) => {
-  let referencesRemovedInThisPass;
-  const shouldBeRemoved = (ident) => {
-    if (isIdentifierReferenced(ident))
-      return false;
-    return true;
-  };
-  const sweepFunction = (path) => {
-    const identifier = getIdentifier(path);
-    if ((identifier == null ? void 0 : identifier.node) && shouldBeRemoved(identifier)) {
-      ++referencesRemovedInThisPass;
-      if (t.isAssignmentExpression(path.parentPath.node) || t.isVariableDeclarator(path.parentPath.node)) {
-        path.parentPath.remove();
-      } else {
-        path.remove();
-      }
-    }
-  };
-  const sweepImport = (path) => {
-    const local = path.get("local");
-    if (shouldBeRemoved(local)) {
-      ++referencesRemovedInThisPass;
-      path.remove();
-      if (path.parent.specifiers.length === 0) {
-        path.parentPath.remove();
-      }
-    }
-  };
-  const handleObjectPattern = (pattern) => {
-    const properties = pattern.get("properties");
-    properties.forEach((property) => {
-      if (property.node.type === "ObjectProperty") {
-        const value = property.get("value");
-        if (t.isIdentifier(value)) {
-          if (shouldBeRemoved(value)) {
-            property.remove();
-          }
-        } else if (t.isObjectPattern(value)) {
-          handleObjectPattern(value);
-        }
-      } else if (t.isRestElement(property.node)) {
-        const argument = property.get("argument");
-        if (t.isIdentifier(argument) && shouldBeRemoved(argument)) {
-          property.remove();
-        }
-      }
-    });
-  };
-  do {
-    referencesRemovedInThisPass = 0;
-    programPath.scope.crawl();
-    programPath.traverse({
-      VariableDeclarator(path) {
-        if (path.node.id.type === "Identifier") {
-          const local = path.get("id");
-          if (shouldBeRemoved(local)) {
-            ++referencesRemovedInThisPass;
-            path.remove();
-          }
-        } else if (path.node.id.type === "ObjectPattern") {
-          handleObjectPattern(
-            path.get("id")
-          );
-        } else if (path.node.id.type === "ArrayPattern") {
-          const pattern = path.get("id");
-          let hasRemoved = false;
-          pattern.get("elements").forEach((element, index) => {
-            let identifierPath;
-            if (t.isIdentifier(element.node)) {
-              identifierPath = element;
-            } else if (t.isRestElement(element.node)) {
-              identifierPath = element.get(
-                "argument"
-              );
-            } else {
-              return;
-            }
-            if (shouldBeRemoved(identifierPath)) {
-              hasRemoved = true;
-              pattern.node.elements[index] = null;
-            }
-          });
-          if (hasRemoved && pattern.node.elements.every((element) => element === null)) {
-            path.remove();
-            ++referencesRemovedInThisPass;
-          }
-        }
-      },
-      FunctionDeclaration: sweepFunction,
-      FunctionExpression: sweepFunction,
-      ArrowFunctionExpression: sweepFunction,
-      ImportSpecifier: sweepImport,
-      ImportDefaultSpecifier: sweepImport,
-      ImportNamespaceSpecifier: sweepImport
-    });
-  } while (referencesRemovedInThisPass);
-};
-function getIdentifier(path) {
-  const parentPath = path.parentPath;
-  if (parentPath.type === "VariableDeclarator") {
-    const variablePath = parentPath;
-    const name = variablePath.get("id");
-    return name.node.type === "Identifier" ? name : null;
-  }
-  if (parentPath.type === "AssignmentExpression") {
-    const variablePath = parentPath;
-    const name = variablePath.get("left");
-    return name.node.type === "Identifier" ? name : null;
-  }
-  if (path.node.type === "ArrowFunctionExpression") {
-    return null;
-  }
-  if (path.node.type === "FunctionExpression") {
-    return null;
-  }
-  return path.node.id && path.node.id.type === "Identifier" ? path.get("id") : null;
-}
-function isIdentifierReferenced(ident) {
-  const binding = ident.scope.getBinding(ident.node.name);
-  if (binding == null ? void 0 : binding.referenced) {
-    if (binding.path.type === "FunctionDeclaration") {
-      return !binding.constantViolations.concat(binding.referencePaths).every((ref) => ref.findParent((parent) => parent === binding.path));
-    }
-    return true;
-  }
-  return false;
-}
-export {
-  eliminateUnreferencedIdentifiers
-};
-//# sourceMappingURL=eliminateUnreferencedIdentifiers.js.map

package/dist/esm/eliminateUnreferencedIdentifiers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"eliminateUnreferencedIdentifiers.js","sources":["../../src/eliminateUnreferencedIdentifiers.ts"],"sourcesContent":["// Copied from https://github.com/pcattori/vite-env-only/blob/main/src/dce.ts\n// Adapted with some minor changes for the purpose of this project\n\nimport * as t from '@babel/types'\nimport type { types as BabelTypes } from '@babel/core'\nimport type { NodePath } from '@babel/traverse'\n\ntype IdentifierPath = NodePath<BabelTypes.Identifier>\n\n/**\n * @param refs - If provided, only these identifiers will be considered for removal.\n */\nexport const eliminateUnreferencedIdentifiers = (\n  programPath: NodePath<BabelTypes.Program>,\n  refs?: Set<IdentifierPath>,\n) => {\n  let referencesRemovedInThisPass: number\n\n  const shouldBeRemoved = (ident: IdentifierPath) => {\n    if (isIdentifierReferenced(ident)) return false\n    if (!refs) return true\n    return refs.has(ident)\n  }\n\n  const sweepFunction = (\n    path: NodePath<\n      | BabelTypes.FunctionDeclaration\n      | BabelTypes.FunctionExpression\n      | BabelTypes.ArrowFunctionExpression\n    >,\n  ) => {\n    const identifier = getIdentifier(path)\n    if (identifier?.node && shouldBeRemoved(identifier)) {\n      ++referencesRemovedInThisPass\n\n      if (\n        t.isAssignmentExpression(path.parentPath.node) ||\n        t.isVariableDeclarator(path.parentPath.node)\n      ) {\n        path.parentPath.remove()\n      } else {\n        path.remove()\n      }\n    }\n  }\n\n  const sweepImport = (\n    path: NodePath<\n      | BabelTypes.ImportSpecifier\n      | BabelTypes.ImportDefaultSpecifier\n      | BabelTypes.ImportNamespaceSpecifier\n    >,\n  ) => {\n    const local = path.get('local')\n    if (shouldBeRemoved(local)) {\n      ++referencesRemovedInThisPass\n      path.remove()\n      if (\n        (path.parent as BabelTypes.ImportDeclaration).specifiers.length === 0\n      ) {\n        path.parentPath.remove()\n      }\n    }\n  }\n\n  const handleObjectPattern = (pattern: NodePath<BabelTypes.ObjectPattern>) => {\n    const properties = pattern.get('properties')\n    properties.forEach((property) => {\n      if (property.node.type === 'ObjectProperty') {\n        const value = property.get('value') as any\n        if (t.isIdentifier(value)) {\n          if (shouldBeRemoved(value as any)) {\n            property.remove()\n          }\n        } else if (t.isObjectPattern(value)) {\n          handleObjectPattern(value as any)\n        }\n      } else if (t.isRestElement(property.node)) {\n        const argument = property.get('argument')\n        if (\n          t.isIdentifier(argument as any) &&\n          shouldBeRemoved(argument as NodePath<BabelTypes.Identifier>)\n        ) {\n          property.remove()\n        }\n      }\n    })\n  }\n\n  // Traverse again to remove unused references. This happens at least once,\n  // then repeats until no more references are removed.\n  do {\n    referencesRemovedInThisPass = 0\n\n    programPath.scope.crawl()\n\n    programPath.traverse({\n      VariableDeclarator(path) {\n        if (path.node.id.type === 'Identifier') {\n          const local = path.get('id') as NodePath<BabelTypes.Identifier>\n          if (shouldBeRemoved(local)) {\n            ++referencesRemovedInThisPass\n            path.remove()\n          }\n        } else if (path.node.id.type === 'ObjectPattern') {\n          handleObjectPattern(\n            path.get('id') as NodePath<BabelTypes.ObjectPattern>,\n          )\n        } else if (path.node.id.type === 'ArrayPattern') {\n          const pattern = path.get('id') as NodePath<BabelTypes.ArrayPattern>\n\n          let hasRemoved = false as boolean\n\n          pattern.get('elements').forEach((element, index) => {\n            // if (!element) return // Skip holes in the pattern\n\n            let identifierPath: NodePath<BabelTypes.Identifier>\n\n            if (t.isIdentifier(element.node)) {\n              identifierPath = element as NodePath<BabelTypes.Identifier>\n            } else if (t.isRestElement(element.node)) {\n              identifierPath = element.get(\n                'argument',\n              ) as NodePath<BabelTypes.Identifier>\n            } else {\n              // For now, ignore other types like AssignmentPattern\n              return\n            }\n\n            if (shouldBeRemoved(identifierPath)) {\n              hasRemoved = true\n              pattern.node.elements[index] = null // Remove the element by setting it to null\n            }\n          })\n\n          // If any elements were removed and no elements are left, remove the entire declaration\n          if (\n            hasRemoved &&\n            pattern.node.elements.every((element) => element === null)\n          ) {\n            path.remove()\n            ++referencesRemovedInThisPass\n          }\n        }\n      },\n      FunctionDeclaration: sweepFunction,\n      FunctionExpression: sweepFunction,\n      ArrowFunctionExpression: sweepFunction,\n      ImportSpecifier: sweepImport,\n      ImportDefaultSpecifier: sweepImport,\n      ImportNamespaceSpecifier: sweepImport,\n    })\n  } while (referencesRemovedInThisPass)\n}\n\nfunction getIdentifier(\n  path: NodePath<\n    | BabelTypes.FunctionDeclaration\n    | BabelTypes.FunctionExpression\n    | BabelTypes.ArrowFunctionExpression\n  >,\n): NodePath<BabelTypes.Identifier> | null {\n  const parentPath = path.parentPath\n  if (parentPath.type === 'VariableDeclarator') {\n    const variablePath = parentPath as NodePath<BabelTypes.VariableDeclarator>\n    const name = variablePath.get('id')\n    return name.node.type === 'Identifier'\n      ? (name as NodePath<BabelTypes.Identifier>)\n      : null\n  }\n\n  if (parentPath.type === 'AssignmentExpression') {\n    const variablePath = parentPath as NodePath<BabelTypes.AssignmentExpression>\n    const name = variablePath.get('left')\n    return name.node.type === 'Identifier'\n      ? (name as NodePath<BabelTypes.Identifier>)\n      : null\n  }\n\n  if (path.node.type === 'ArrowFunctionExpression') {\n    return null\n  }\n\n  if (path.node.type === 'FunctionExpression') {\n    return null\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  return path.node.id && path.node.id.type === 'Identifier'\n    ? (path.get('id') as NodePath<BabelTypes.Identifier>)\n    : null\n}\n\nfunction isIdentifierReferenced(\n  ident: NodePath<BabelTypes.Identifier>,\n): boolean {\n  const binding = ident.scope.getBinding(ident.node.name)\n  if (binding?.referenced) {\n    // Functions can reference themselves, so we need to check if there's a\n    // binding outside the function scope or not.\n    if (binding.path.type === 'FunctionDeclaration') {\n      return !binding.constantViolations\n        .concat(binding.referencePaths)\n        // Check that every reference is contained within the function:\n        .every((ref) => ref.findParent((parent) => parent === binding.path))\n    }\n\n    return true\n  }\n  return false\n}\n"],"names":[],"mappings":"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"}

package/src/compilers.ts

@@ -1,462 +0,0 @@
-import * as t from '@babel/types'
-import * as template from '@babel/template'
-import * as babel from '@babel/core'
-import { splitPrefix } from './constants'
-import { eliminateUnreferencedIdentifiers } from './eliminateUnreferencedIdentifiers'
-
-type SplitModulesById = Record<
-  string,
-  { id: string; node: t.FunctionExpression }
->
-
-interface State {
-  filename: string
-  opts: {
-    minify: boolean
-    root: string
-  }
-  imported: Record<string, boolean>
-  refs: Set<any>
-  serverIndex: number
-  splitIndex: number
-  splitModulesById: SplitModulesById
-}
-
-export type CompileFn = (compileOpts: {
-  code: string
-  filename: string
-  getBabelConfig: () => { plugins: Array<any> }
-}) => Promise<{
-  code: string
-  map: any
-}>
-
-export function makeCompile(makeOpts: { root: string }) {
-  return async (opts: {
-    code: string
-    filename: string
-    getBabelConfig: () => { plugins: Array<any> }
-  }): Promise<{
-    code: string
-    map: any
-  }> => {
-    const res = await babel.transform(opts.code, {
-      plugins: [
-        ['@babel/plugin-syntax-jsx', {}],
-        [
-          '@babel/plugin-syntax-typescript',
-          {
-            isTSX: true,
-          },
-        ],
-        ...opts.getBabelConfig().plugins,
-      ],
-      root: makeOpts.root,
-      filename: opts.filename,
-      sourceMaps: true,
-    })
-
-    if (res?.code) {
-      return {
-        code: res.code,
-        map: res.map,
-      }
-    }
-
-    return {
-      code: opts.code,
-      map: null,
-    }
-  }
-}
-
-export async function compileFile(opts: {
-  code: string
-  compile: CompileFn
-  filename: string
-}) {
-  return await opts.compile({
-    code: opts.code,
-    filename: opts.filename,
-    getBabelConfig: () => ({
-      plugins: [
-        [
-          {
-            visitor: {
-              Program: {
-                enter(programPath: babel.NodePath<t.Program>, state: State) {
-                  const splitUrl = `${splitPrefix}:${opts.filename}?${splitPrefix}`
-
-                  programPath.traverse(
-                    {
-                      CallExpression: (path) => {
-                        if (path.node.callee.type === 'Identifier') {
-                          if (
-                            path.node.callee.name === 'createRoute' ||
-                            path.node.callee.name === 'createFileRoute'
-                          ) {
-                            if (
-                              path.parentPath.node.type === 'CallExpression'
-                            ) {
-                              const options = resolveIdentifier(
-                                path,
-                                path.parentPath.node.arguments[0],
-                              )
-
-                              let found = false
-
-                              const hasImportedOrDefinedIdentifier = (
-                                name: string,
-                              ) => {
-                                return programPath.scope.hasBinding(name)
-                              }
-
-                              if (t.isObjectExpression(options)) {
-                                options.properties.forEach((prop) => {
-                                  if (t.isObjectProperty(prop)) {
-                                    if (t.isIdentifier(prop.key)) {
-                                      if (prop.key.name === 'component') {
-                                        const value = prop.value
-
-                                        if (t.isIdentifier(value)) {
-                                          removeIdentifierLiteral(path, value)
-                                        }
-
-                                        // Prepend the import statement to the program along with the importer function
-                                        // Check to see if lazyRouteComponent is already imported before attempting
-                                        // to import it again
-
-                                        if (
-                                          !hasImportedOrDefinedIdentifier(
-                                            'lazyRouteComponent',
-                                          )
-                                        ) {
-                                          programPath.unshiftContainer('body', [
-                                            template.smart(
-                                              `import { lazyRouteComponent } from '@tanstack/react-router'`,
-                                            )() as t.Statement,
-                                          ])
-                                        }
-
-                                        if (
-                                          !hasImportedOrDefinedIdentifier(
-                                            '$$splitComponentImporter',
-                                          )
-                                        ) {
-                                          programPath.unshiftContainer('body', [
-                                            template.smart(
-                                              `const $$splitComponentImporter = () => import('${splitUrl}')`,
-                                            )() as t.Statement,
-                                          ])
-                                        }
-
-                                        prop.value = template.expression(
-                                          `lazyRouteComponent($$splitComponentImporter, 'component')`,
-                                        )() as any
-
-                                        programPath.pushContainer('body', [
-                                          template.smart(
-                                            `function DummyComponent() { return null }`,
-                                          )() as t.Statement,
-                                        ])
-
-                                        found = true
-                                      } else if (prop.key.name === 'loader') {
-                                        const value = prop.value
-
-                                        if (t.isIdentifier(value)) {
-                                          removeIdentifierLiteral(path, value)
-                                        }
-
-                                        // Prepend the import statement to the program along with the importer function
-
-                                        if (
-                                          !hasImportedOrDefinedIdentifier(
-                                            'lazyFn',
-                                          )
-                                        ) {
-                                          programPath.unshiftContainer('body', [
-                                            template.smart(
-                                              `import { lazyFn } from '@tanstack/react-router'`,
-                                            )() as t.Statement,
-                                          ])
-                                        }
-
-                                        if (
-                                          !hasImportedOrDefinedIdentifier(
-                                            '$$splitLoaderImporter',
-                                          )
-                                        ) {
-                                          programPath.unshiftContainer('body', [
-                                            template.smart(
-                                              `const $$splitLoaderImporter = () => import('${splitUrl}')`,
-                                            )() as t.Statement,
-                                          ])
-                                        }
-
-                                        prop.value = template.expression(
-                                          `lazyFn($$splitLoaderImporter, 'loader')`,
-                                        )() as any
-
-                                        found = true
-                                      }
-                                    }
-                                  }
-
-                                  programPath.scope.crawl()
-                                })
-                              }
-
-                              if (found as boolean) {
-                                programPath.pushContainer('body', [
-                                  template.smart(
-                                    `function TSR_Dummy_Component() {}`,
-                                  )() as t.Statement,
-                                ])
-                              }
-                            }
-                          }
-                        }
-                      },
-                    },
-                    state,
-                  )
-
-                  eliminateUnreferencedIdentifiers(programPath)
-                },
-              },
-            },
-          },
-          {
-            root: process.cwd(),
-            minify: process.env.NODE_ENV === 'production',
-          },
-        ],
-      ].filter(Boolean),
-    }),
-  })
-}
-
-// Reusable function to get literal value or resolve variable to literal
-function resolveIdentifier(path: any, node: any) {
-  if (t.isIdentifier(node)) {
-    const binding = path.scope.getBinding(node.name)
-    if (
-      binding
-      // && binding.kind === 'const'
-    ) {
-      const declarator = binding.path.node
-      if (t.isObjectExpression(declarator.init)) {
-        return declarator.init
-      } else if (t.isFunctionDeclaration(declarator.init)) {
-        return declarator.init
-      }
-    }
-    return undefined
-  }
-
-  return node
-}
-
-function removeIdentifierLiteral(path: any, node: any) {
-  if (t.isIdentifier(node)) {
-    const binding = path.scope.getBinding(node.name)
-    if (binding) {
-      binding.path.remove()
-    }
-  }
-}
-
-const splitNodeTypes = ['component', 'loader'] as const
-type SplitNodeType = (typeof splitNodeTypes)[number]
-
-export async function splitFile(opts: {
-  code: string
-  compile: CompileFn
-  filename: string
-  // ref: string
-}) {
-  return await opts.compile({
-    code: opts.code,
-    filename: opts.filename,
-    getBabelConfig: () => ({
-      plugins: [
-        [
-          {
-            visitor: {
-              Program: {
-                enter(programPath: babel.NodePath<t.Program>, state: State) {
-                  const splitNodesByType: Record<
-                    SplitNodeType,
-                    t.Node | undefined
-                  > = {
-                    component: undefined,
-                    loader: undefined,
-                  }
-
-                  // Find the node
-                  programPath.traverse(
-                    {
-                      CallExpression: (path) => {
-                        if (path.node.callee.type === 'Identifier') {
-                          if (
-                            path.node.callee.name === 'createRoute' ||
-                            path.node.callee.name === 'createFileRoute'
-                          ) {
-                            if (
-                              path.parentPath.node.type === 'CallExpression'
-                            ) {
-                              const options = resolveIdentifier(
-                                path,
-                                path.parentPath.node.arguments[0],
-                              )
-
-                              if (t.isObjectExpression(options)) {
-                                options.properties.forEach((prop) => {
-                                  if (t.isObjectProperty(prop)) {
-                                    splitNodeTypes.forEach((type) => {
-                                      if (t.isIdentifier(prop.key)) {
-                                        if (prop.key.name === type) {
-                                          splitNodesByType[type] = prop.value
-                                        }
-                                      }
-                                    })
-                                  }
-                                })
-
-                                // Remove all of the options
-                                options.properties = []
-                              }
-                            }
-                          }
-                        }
-                      },
-                    },
-                    state,
-                  )
-
-                  splitNodeTypes.forEach((splitType) => {
-                    let splitNode = splitNodesByType[splitType]
-
-                    if (!splitNode) {
-                      return
-                    }
-
-                    while (t.isIdentifier(splitNode)) {
-                      const binding = programPath.scope.getBinding(
-                        splitNode.name,
-                      )
-                      splitNode = binding?.path.node
-                    }
-
-                    // Add the node to the program
-                    if (splitNode) {
-                      if (t.isFunctionDeclaration(splitNode)) {
-                        programPath.pushContainer(
-                          'body',
-                          t.variableDeclaration('const', [
-                            t.variableDeclarator(
-                              t.identifier(splitType),
-                              t.functionExpression(
-                                splitNode.id || null, // Anonymize the function expression
-                                splitNode.params,
-                                splitNode.body,
-                                splitNode.generator,
-                                splitNode.async,
-                              ),
-                            ),
-                          ]),
-                        )
-                      } else if (
-                        t.isFunctionExpression(splitNode) ||
-                        t.isArrowFunctionExpression(splitNode)
-                      ) {
-                        programPath.pushContainer(
-                          'body',
-                          t.variableDeclaration('const', [
-                            t.variableDeclarator(
-                              t.identifier(splitType),
-                              splitNode as any,
-                            ),
-                          ]),
-                        )
-                      } else if (t.isImportSpecifier(splitNode)) {
-                        programPath.pushContainer(
-                          'body',
-                          t.variableDeclaration('const', [
-                            t.variableDeclarator(
-                              t.identifier(splitType),
-                              splitNode.local,
-                            ),
-                          ]),
-                        )
-                      } else {
-                        console.info(splitNode)
-                        throw new Error(
-                          `Unexpected splitNode type ☝️: ${splitNode.type}`,
-                        )
-                      }
-                    }
-
-                    // If the splitNode exists at the top of the program
-                    // then we need to remove that copy
-                    programPath.node.body = programPath.node.body.filter(
-                      (node) => {
-                        return node !== splitNode
-                      },
-                    )
-
-                    // Export the node
-                    programPath.pushContainer('body', [
-                      t.exportNamedDeclaration(null, [
-                        t.exportSpecifier(
-                          t.identifier(splitType),
-                          t.identifier(splitType),
-                        ),
-                      ]),
-                    ])
-                  })
-
-                  // convert exports to imports from the original file
-                  programPath.traverse({
-                    ExportNamedDeclaration(path) {
-                      // e.g. export const x = 1 or export { x }
-                      // becomes
-                      // import { x } from '${opts.id}'
-
-                      if (path.node.declaration) {
-                        if (t.isVariableDeclaration(path.node.declaration)) {
-                          path.replaceWith(
-                            t.importDeclaration(
-                              path.node.declaration.declarations.map((decl) =>
-                                t.importSpecifier(
-                                  t.identifier((decl.id as any).name),
-                                  t.identifier((decl.id as any).name),
-                                ),
-                              ),
-                              t.stringLiteral(
-                                opts.filename.split(
-                                  `?${splitPrefix}`,
-                                )[0] as string,
-                              ),
-                            ),
-                          )
-                        }
-                      }
-                    },
-                  })
-
-                  eliminateUnreferencedIdentifiers(programPath)
-                },
-              },
-            },
-          },
-          {
-            root: process.cwd(),
-            minify: process.env.NODE_ENV === 'production',
-          },
-        ],
-      ].filter(Boolean),
-    }),
-  })
-}

package/src/constants.ts

@@ -1 +0,0 @@
-export const splitPrefix = 'tsr-split'