@tanstack/router-cli 0.0.1-beta.69 → 1.0.0

package/src/watch.ts

@@ -5,41 +5,44 @@ import { generator } from './generator'
 
 export async function watch() {
   const configWatcher = chokidar.watch(
-    path.resolve(process.cwd(), 'tsr.config.js'),
+    path.resolve(process.cwd(), 'tsr.config.json'),
   )
 
-  let watcher = new chokidar.FSWatcher()
+  let watcher = new chokidar.FSWatcher({})
 
   const generatorWatcher = async () => {
     const config = await getConfig()
 
     watcher.close()
 
-    console.log(`TSR: Watching routes (${config.routesDirectory})...`)
+    console.info(`TSR: Watching routes (${config.routesDirectory})...`)
     watcher = chokidar.watch(config.routesDirectory)
 
     watcher.on('ready', async () => {
-      try {
-        await generator(config)
-      } catch (err) {
-        console.error(err)
-        console.log()
-      }
-
       const handle = async () => {
         try {
           await generator(config)
         } catch (err) {
           console.error(err)
-          console.log()
+          console.info()
+        }
+      }
+
+      await handle()
+
+      let timeout: ReturnType<typeof setTimeout>
+
+      const deduped = (file: string) => {
+        if (timeout) {
+          clearTimeout(timeout)
         }
+
+        timeout = setTimeout(handle, 10)
       }
 
-      watcher.on('change', handle)
-      watcher.on('add', handle)
-      watcher.on('addDir', handle)
-      watcher.on('unlink', handle)
-      watcher.on('unlinkDir', handle)
+      watcher.on('change', deduped)
+      watcher.on('add', deduped)
+      watcher.on('unlink', deduped)
     })
   }
 

package/build/cjs/transformCode.js

@@ -1,584 +0,0 @@
-/**
- * router-cli
- *
- * Copyright (c) TanStack
- *
- * 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 babel = require('@babel/core');
-var t = require('@babel/types');
-var syntaxTS = require('@babel/plugin-syntax-typescript');
-var generator = require('./generator.js');
-var path = require('path');
-
-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 babel__namespace = /*#__PURE__*/_interopNamespace(babel);
-var t__namespace = /*#__PURE__*/_interopNamespace(t);
-var syntaxTS__default = /*#__PURE__*/_interopDefaultLegacy(syntaxTS);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-
-const isolatedProperties = ['component', 'errorComponent', 'pendingComponent'];
-const getBasePlugins = () => [[syntaxTS__default["default"], {
-  isTSX: true
-}]];
-async function ensureBoilerplate(node, code) {
-  const relativeImportPath = path__default["default"].relative(node.fullDir, node.genPathNoExt);
-  const originalFile = await babel__namespace.transformAsync(code, {
-    configFile: false,
-    babelrc: false,
-    plugins: [...getBasePlugins()]
-  });
-  const file = await babel__namespace.transformAsync(code, {
-    configFile: false,
-    babelrc: false,
-    plugins: [...getBasePlugins(), {
-      visitor: {
-        Program: {
-          enter(programPath) {
-            // Remove all properties except for our isolated one
-            if (node.isRoot) {
-              let foundImport = false;
-              programPath.traverse({
-                ImportSpecifier(importPath) {
-                  if (t__namespace.isIdentifier(importPath.node.imported) && importPath.node.imported.name === 'Route') {
-                    foundImport = true;
-                  }
-                }
-              });
-              if (!foundImport) {
-                programPath.node.body.unshift(babel__namespace.template.statement(`import { Route } from '@tanstack/react-router'`)());
-              }
-            } else {
-              let foundImport = false;
-              programPath.traverse({
-                ImportSpecifier(importPath) {
-                  if (t__namespace.isIdentifier(importPath.node.imported) && importPath.node.imported.name === 'route') {
-                    foundImport = true;
-                    if (t__namespace.isImportDeclaration(importPath.parentPath.node)) {
-                      if (importPath.parentPath.node.source.value !== relativeImportPath) {
-                        importPath.parentPath.node.source.value = relativeImportPath;
-                      }
-                    }
-                  }
-                }
-              });
-              if (!foundImport) {
-                programPath.node.body.unshift(babel__namespace.template.statement(`import { Route } from '${relativeImportPath.replace(/\\/gi, '/')}'`)());
-              }
-            }
-          }
-        }
-      }
-    }]
-  });
-  const separator = 'new Route(';
-  if (!originalFile?.code) {
-    return `${file?.code}\n\n${separator}{\n\n})`;
-  }
-  const originalHead = originalFile?.code?.substring(0, originalFile?.code?.indexOf(separator));
-  const generatedHead = file?.code?.substring(0, file?.code?.indexOf(separator));
-  if (originalHead !== generatedHead) {
-    return `${generatedHead}\n\n${originalFile?.code?.substring(originalFile?.code?.indexOf(separator))}`;
-  }
-  return;
-}
-async function isolateOptionToExport(node, code, opts) {
-  return (await babel__namespace.transformAsync(code, {
-    configFile: false,
-    babelrc: false,
-    plugins: [...getBasePlugins(), plugin()],
-    ast: true
-  }))?.code;
-  function plugin() {
-    return {
-      visitor: {
-        Program: {
-          enter(programPath, state) {
-            // If we're the root, handle things a bit differently
-            if (node.isRoot) {
-              programPath.traverse({
-                Identifier(path) {
-                  if (path.node.name === 'Route' && t__namespace.isCallExpression(path.parentPath.node)) {
-                    const options = getRouteOptions(path);
-                    if (options) {
-                      const property = options.properties.find(property => {
-                        return t__namespace.isObjectProperty(property) && t__namespace.isIdentifier(property.key) && property.key.name === opts.isolate;
-                      });
-                      if (t__namespace.isObjectProperty(property)) {
-                        const program = path.findParent(d => d.isProgram());
-                        if (program?.isProgram()) {
-                          program.node.body.push(babel__namespace.template.statement(`export const ${opts.isolate} = $VAR`)({
-                            $VAR: property.value
-                          }));
-                        }
-                      }
-                      path.findParent(d => d.isExpressionStatement())?.remove();
-                    }
-                  }
-                }
-              });
-            }
-
-            // We're not in the root, handle things normally
-            if (!node.isRoot) {
-              // Remove all properties except for our isolated one
-              programPath.traverse({
-                Identifier(path) {
-                  if (path.node.name === 'generate') {
-                    const options = getRouteConfigGenerateOptions(path);
-                    if (options) {
-                      const property = options.properties.find(property => {
-                        return t__namespace.isObjectProperty(property) && t__namespace.isIdentifier(property.key) && property.key.name === opts.isolate;
-                      });
-                      if (t__namespace.isObjectProperty(property) && t__namespace.isIdentifier(property.key)) {
-                        if (property.key.name === opts.isolate) {
-                          const program = path.findParent(d => d.isProgram());
-                          if (program?.isProgram()) {
-                            program.node.body.push(babel__namespace.template.statement(`export const ${opts.isolate} = $VAR`)({
-                              $VAR: property.value
-                            }));
-                          }
-                        }
-                      }
-                      path.findParent(d => d.isExpressionStatement())?.remove();
-                    }
-                  }
-                }
-              });
-            }
-            cleanUnusedCode(programPath, state, [opts.isolate]);
-          }
-        }
-      }
-    };
-  }
-}
-async function detectExports(code) {
-  let exported = [];
-
-  // try {
-  await babel__namespace.transformAsync(code, {
-    configFile: false,
-    babelrc: false,
-    plugins: [...getBasePlugins(), {
-      visitor: {
-        ExportNamedDeclaration(path) {
-          if (t__namespace.isVariableDeclaration(path.node.declaration)) {
-            if (t__namespace.isVariableDeclarator(path.node.declaration.declarations?.[0])) {
-              if (t__namespace.isIdentifier(path.node.declaration.declarations[0].id)) {
-                exported.push(path.node.declaration.declarations[0].id.name);
-              }
-            }
-          }
-        }
-      }
-    }],
-    ast: true
-  });
-  return exported;
-}
-async function generateRouteConfig(node, routeCode, imports, clientOnly) {
-  const relativeParentRoutePath = clientOnly ? node.parent ? generator.removeExt(path__default["default"].relative(node.genDir, path__default["default"].resolve(node.parent?.genDir, node.parent?.clientFilename))) : `./${generator.rootRouteClientName}` : node.parent ? generator.removeExt(path__default["default"].relative(node.genDir, path__default["default"].resolve(node.parent?.genDir, node.parent?.filename))) : `./${generator.rootRouteName}`;
-  const pathName = node.isRoot ? undefined : node.fileNameNoExt.startsWith('__') ? undefined : node.fileNameNoExt === 'index' ? '/' : node.fileNameNoExt;
-  const routeId = node.isRoot ? undefined : node.fileNameNoExt;
-  function plugin() {
-    return {
-      visitor: {
-        Program: {
-          enter(programPath, state) {
-            // Remove all of the isolated import properties from the config
-            programPath.traverse({
-              ImportSpecifier(path) {
-                if (t__namespace.isIdentifier(path.node.imported)) {
-                  if (!node.isRoot) {
-                    if (path.node.imported.name === 'route') {
-                      path.parentPath.remove();
-                      const program = path.findParent(d => d.isProgram());
-                      if (program?.isProgram()) {
-                        program.node.body.unshift(babel__namespace.template.statement(`import { route as parentRoute } from '$IMPORT'`)({
-                          $IMPORT: relativeParentRoutePath
-                        }));
-                      }
-                    }
-                  }
-                }
-              },
-              Identifier(iPath) {
-                let options;
-                if (node.isRoot) {
-                  if (iPath.node.name === 'Route') {
-                    if (t__namespace.isCallExpression(iPath.parentPath.node)) {
-                      if (t__namespace.isExpressionStatement(iPath.parentPath.parentPath?.node)) {
-                        iPath.parentPath.parentPath?.replaceWith(t__namespace.variableDeclaration('const', [t__namespace.variableDeclarator(t__namespace.identifier('route'), iPath.parentPath.node)]));
-                      }
-                    }
-                  }
-                } else {
-                  if (iPath.node.name === 'generate') {
-                    if (t__namespace.isMemberExpression(iPath.parentPath.node)) {
-                      if (t__namespace.isIdentifier(iPath.parentPath.node.object)) {
-                        iPath.node.name = 'Route';
-                        iPath.parentPath.node.object.name = 'parentRoute';
-                        options = getRouteConfigGenerateOptions(iPath);
-                      }
-                    }
-                  }
-                }
-                if (options) {
-                  options.properties = [...(pathName ? [t__namespace.objectProperty(t__namespace.identifier('path'), t__namespace.stringLiteral(pathName))] : routeId ? [t__namespace.objectProperty(t__namespace.identifier('id'), t__namespace.stringLiteral(routeId))] : []), ...options.properties.map(property => {
-                    if (t__namespace.isObjectProperty(property) && t__namespace.isIdentifier(property.key) && isolatedProperties.includes(property.key.name)) {
-                      const key = property.key.name;
-                      if (key === 'loader') {
-                        if (clientOnly) {
-                          return t__namespace.objectProperty(t__namespace.identifier('loader'), t__namespace.tSAsExpression(t__namespace.booleanLiteral(true), t__namespace.tsAnyKeyword()));
-                        }
-                        return t__namespace.objectProperty(t__namespace.identifier(key), babel__namespace.template.expression(`(...args) => import('./${path__default["default"].relative(node.genDir, node.genPathNoExt)}-${key}').then(d => d.${key}.apply(d.${key}, (args as any)))`, {
-                          plugins: ['typescript']
-                        })({}));
-                      }
-                      if (key === 'action') {
-                        if (clientOnly) {
-                          return t__namespace.objectProperty(t__namespace.identifier('action'), t__namespace.tSAsExpression(t__namespace.booleanLiteral(true), t__namespace.tSAnyKeyword()));
-                        }
-                        return t__namespace.objectProperty(t__namespace.identifier(key), babel__namespace.template.expression(`(...payload: Parameters<typeof import('./${path__default["default"].relative(node.genDir, node.genPathNoExt)}-${key}').action>) => import('./${path__default["default"].relative(node.genDir, node.genPathNoExt)}-${key}').then(d => d.${key}.apply(d.${key}, (payload as any)))`, {
-                          plugins: ['typescript']
-                        })({}));
-                      }
-                      if (clientOnly) {
-                        return t__namespace.objectProperty(t__namespace.identifier(key), babel__namespace.template.expression(`
-                                lazy(() => import('./${path__default["default"].relative(node.genDir, node.genPathNoExt)}-${key}').then(d => ({ default: d.${key} }) ))`)());
-                      }
-                      return t__namespace.objectProperty(t__namespace.identifier(key), property.value);
-                    }
-                    return property;
-                  })];
-                  const program = iPath.findParent(d => d.isProgram());
-                  if (program?.isProgram() && options) {
-                    const index = program.node.body.findIndex(d => d.start === iPath.parentPath.parentPath?.node.start);
-                    if (node.isRoot) {
-                      program.node.body[index] = babel__namespace.template.statement(`const route = new Route(
-                          $OPTIONS
-                          )`)({
-                        $OPTIONS: options
-                      });
-                    } else {
-                      program.node.body[index] = babel__namespace.template.statement(`const route = new Route(
-                          $OPTIONS
-                          )`)({
-                        $OPTIONS: options
-                      });
-                    }
-                  }
-                }
-              }
-            });
-            programPath.node.body.unshift(babel__namespace.template.statement(`import { lazy } from '@tanstack/react-router'`)());
-
-            // Add the route exports
-            programPath.node.body.push(babel__namespace.template.statement(clientOnly ? `export { route, route as ${node.variable}Route }` : `export { route }`)());
-            cleanUnusedCode(programPath, state, ['route', `${node.variable}Route`]);
-          }
-        }
-      }
-    };
-  }
-  const code = (await babel__namespace.transformAsync(routeCode, {
-    configFile: false,
-    babelrc: false,
-    plugins: [...getBasePlugins(), plugin()],
-    ast: true
-  }))?.code;
-  if (!code) {
-    throw new Error('Error while generating a route file!');
-  }
-  return code;
-}
-function getIdentifier(path) {
-  const parentPath = path.parentPath;
-  if (parentPath.type === 'VariableDeclarator') {
-    const pp = parentPath;
-    const name = pp.get('id');
-    return name.node.type === 'Identifier' ? name : null;
-  }
-  if (parentPath.type === 'AssignmentExpression') {
-    const pp = parentPath;
-    const name = pp.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) {
-  const b = ident.scope.getBinding(ident.node.name);
-  if (b && b.referenced) {
-    if (b.path.type === 'FunctionDeclaration') {
-      return !b.constantViolations.concat(b.referencePaths).every(ref => ref.findParent(p => p === b.path));
-    }
-    return true;
-  }
-  return false;
-}
-function markFunction(path, state) {
-  const ident = getIdentifier(path);
-  if (ident && ident.node && isIdentifierReferenced(ident)) {
-    state.refs.add(ident);
-  }
-}
-function markImport(path, state) {
-  const local = path.get('local');
-  if (isIdentifierReferenced(local)) {
-    state.refs.add(local);
-  }
-}
-function getRouteConfigGenerateOptions(path) {
-  const tryOptions = node => {
-    if (t__namespace.isIdentifier(node)) {
-      const initNode = path.scope.getBinding(node.name)?.path.node;
-      if (t__namespace.isVariableDeclarator(initNode)) {
-        return tryOptions(initNode.init);
-      }
-    } else if (t__namespace.isObjectExpression(node)) {
-      return node;
-    }
-    return;
-  };
-  if (t__namespace.isMemberExpression(path.parentPath.node) && t__namespace.isCallExpression(path.parentPath.parentPath?.node)) {
-    const options = path.parentPath.parentPath?.node.arguments[0];
-    return tryOptions(options);
-  }
-}
-function getRouteOptions(path) {
-  const tryOptions = node => {
-    if (t__namespace.isIdentifier(node)) {
-      const initNode = path.scope.getBinding(node.name)?.path.node;
-      if (t__namespace.isVariableDeclarator(initNode)) {
-        return tryOptions(initNode.init);
-      }
-    } else if (t__namespace.isObjectExpression(node)) {
-      return node;
-    }
-    return;
-  };
-  if (t__namespace.isCallExpression(path.parentPath?.node)) {
-    const options = path.parentPath?.node.arguments[0];
-    return tryOptions(options);
-  }
-}
-
-// All credit for this amazing function goes to the Next.js team
-// (and the Solid.js team for their derivative work).
-// https://github.com/vercel/next.js/blob/canary/packages/next/build/babel/plugins/next-ssg-transform.ts
-// https://github.com/solidjs/solid-start/blob/main/packages/start/server/routeData.js
-
-function cleanUnusedCode(programPath, state, keepExports = []) {
-  state.refs = new Set();
-  state.done = false;
-  function markVariable(variablePath, variableState) {
-    if (variablePath.node.id.type === 'Identifier') {
-      const local = variablePath.get('id');
-      if (isIdentifierReferenced(local)) {
-        variableState.refs.add(local);
-      }
-    } else if (variablePath.node.id.type === 'ObjectPattern') {
-      const pattern = variablePath.get('id');
-      const properties = pattern.get('properties');
-      properties.forEach(p => {
-        const local = p.get(p.node.type === 'ObjectProperty' ? 'value' : p.node.type === 'RestElement' ? 'argument' : function () {
-          throw new Error('invariant');
-        }());
-        if (isIdentifierReferenced(local)) {
-          variableState.refs.add(local);
-        }
-      });
-    } else if (variablePath.node.id.type === 'ArrayPattern') {
-      const pattern = variablePath.get('id');
-      const elements = pattern.get('elements');
-      elements.forEach(e => {
-        let local;
-        if (e.node && e.node.type === 'Identifier') {
-          local = e;
-        } else if (e.node && e.node.type === 'RestElement') {
-          local = e.get('argument');
-        } else {
-          return;
-        }
-        if (isIdentifierReferenced(local)) {
-          variableState.refs.add(local);
-        }
-      });
-    }
-  }
-
-  // Mark all variables and functions if used
-  programPath.traverse({
-    VariableDeclarator: markVariable,
-    FunctionDeclaration: markFunction,
-    FunctionExpression: markFunction,
-    ArrowFunctionExpression: markFunction,
-    ImportSpecifier: markImport,
-    ImportDefaultSpecifier: markImport,
-    ImportNamespaceSpecifier: markImport,
-    ExportDefaultDeclaration: markImport,
-    // ExportNamedDeclaration(path, state) {
-    //   if (t.isVariableDeclaration(path.node.declaration)) {
-    //     if (t.isVariableDeclarator(path.node.declaration.declarations?.[0])) {
-    //       if (t.isIdentifier(path.node.declaration.declarations[0].id)) {
-    //         if (
-    //           keepExports.includes(
-    //             path.node.declaration.declarations[0].id.name,
-    //           )
-    //         ) {
-    //           return
-    //         }
-    //       }
-    //       path.replaceWith(path.node.declaration.declarations[0])
-    //       return
-    //     }
-    //   }
-    //   path.remove()
-    // },
-    ImportDeclaration: path => {
-      if (path.node.source.value.endsWith('.css')) {
-        path.remove();
-      }
-    }
-  }, state);
-
-  // Sweet all of the remaining references and remove unused ones
-  const refs = state.refs;
-  let count;
-  function sweepFunction(sweepPath) {
-    const ident = getIdentifier(sweepPath);
-    if (ident && ident.node && refs.has(ident) && !isIdentifierReferenced(ident)) {
-      ++count;
-      if (t__namespace.isAssignmentExpression(sweepPath.parentPath) || t__namespace.isVariableDeclarator(sweepPath.parentPath)) {
-        sweepPath.parentPath.remove();
-      } else {
-        sweepPath.remove();
-      }
-    }
-  }
-  function sweepImport(sweepPath) {
-    const local = sweepPath.get('local');
-    if (refs.has(local) && !isIdentifierReferenced(local)) {
-      ++count;
-      sweepPath.remove();
-      if (sweepPath.parent.specifiers.length === 0) {
-        sweepPath.parentPath.remove();
-      }
-    }
-  }
-  do {
-    programPath.scope.crawl();
-    count = 0;
-    programPath.traverse({
-      VariableDeclarator(variablePath) {
-        if (variablePath.node.id.type === 'Identifier') {
-          const local = variablePath.get('id');
-          if (refs.has(local) && !isIdentifierReferenced(local)) {
-            ++count;
-            variablePath.remove();
-          }
-        } else if (variablePath.node.id.type === 'ObjectPattern') {
-          const pattern = variablePath.get('id');
-          const beforeCount = count;
-          const properties = pattern.get('properties');
-          properties.forEach(p => {
-            const local = p.get(p.node.type === 'ObjectProperty' ? 'value' : p.node.type === 'RestElement' ? 'argument' : function () {
-              throw new Error('invariant');
-            }());
-            if (refs.has(local) && !isIdentifierReferenced(local)) {
-              ++count;
-              p.remove();
-            }
-          });
-          if (beforeCount !== count && pattern.get('properties').length < 1) {
-            variablePath.remove();
-          }
-        } else if (variablePath.node.id.type === 'ArrayPattern') {
-          const pattern = variablePath.get('id');
-          const beforeCount = count;
-          const elements = pattern.get('elements');
-          elements.forEach(e => {
-            let local;
-            if (e.node && e.node.type === 'Identifier') {
-              local = e;
-            } else if (e.node && e.node.type === 'RestElement') {
-              local = e.get('argument');
-            } else {
-              return;
-            }
-            if (refs.has(local) && !isIdentifierReferenced(local)) {
-              ++count;
-              e.remove();
-            }
-          });
-          if (beforeCount !== count && pattern.get('elements').length < 1) {
-            variablePath.remove();
-          }
-        }
-      },
-      FunctionDeclaration: sweepFunction,
-      FunctionExpression: sweepFunction,
-      ArrowFunctionExpression: sweepFunction,
-      ImportSpecifier: sweepImport,
-      ImportDefaultSpecifier: sweepImport,
-      ImportNamespaceSpecifier: sweepImport
-    });
-  } while (count);
-
-  // Do we need the * import for react?
-  let hasReact = false;
-
-  // Mark react elements as having react
-  programPath.traverse({
-    JSXElement(path) {
-      hasReact = true;
-    }
-  });
-  if (!hasReact) {
-    // Mark all variables and functions if used
-    programPath.traverse({
-      ImportDeclaration(path) {
-        if (t__namespace.isStringLiteral(path.node.source) && path.node.source.value === 'react' && t__namespace.isImportNamespaceSpecifier(path.node.specifiers[0])) {
-          path.remove();
-        }
-      }
-    });
-  }
-}
-
-exports.detectExports = detectExports;
-exports.ensureBoilerplate = ensureBoilerplate;
-exports.generateRouteConfig = generateRouteConfig;
-exports.isolateOptionToExport = isolateOptionToExport;
-exports.isolatedProperties = isolatedProperties;
-//# sourceMappingURL=transformCode.js.map