@solidjs/start 2.0.0-beta.1 → 2.0.0-beta.10

package/src/config/fs-routes/router.ts

@@ -1,184 +0,0 @@
-import { init, parse } from "es-module-lexer";
-import esbuild from "esbuild";
-import fg from "fast-glob";
-import fs from "node:fs";
-import micromatch from "micromatch";
-import { posix } from "node:path";
-import { pathToRegexp } from "path-to-regexp";
-
-import { normalizePath } from "vite";
-
-export { pathToRegexp };
-
-export const glob = (path: string) => fg.sync(path, { absolute: true });
-
-export type FileSystemRouterConfig = { dir: string; extensions: string[] };
-type Route = { path: string } & Record<string, any>;
-
-export function cleanPath(src: string, config: FileSystemRouterConfig) {
-  return src
-    .slice(config.dir.length)
-    .replace(new RegExp(`\.(${(config.extensions ?? []).join("|")})$`), "");
-}
-
-export function analyzeModule(src: string) {
-  return parse(
-    esbuild.transformSync(fs.readFileSync(src, "utf-8"), {
-      jsx: "transform",
-      format: "esm",
-      loader: "tsx",
-    }).code,
-    src,
-  );
-}
-
-type RouterEvent = CustomEvent<{ route: string; type: "update" | "remove" | "add" }>;
-
-export class BaseFileSystemRouter extends EventTarget {
-  routes: Route[];
-
-  config: FileSystemRouterConfig;
-
-  /**
-   *
-   * @param {} config
-   */
-  constructor(config: FileSystemRouterConfig) {
-    super();
-    this.routes = [];
-    this.config = config;
-  }
-
-  glob() {
-    return (
-      posix.join(fg.convertPathToPattern(this.config.dir), "**/*") +
-      `.{${this.config.extensions.join(",")}}`
-    );
-  }
-
-  async buildRoutes(): Promise<any[]> {
-    await init;
-    for (var src of glob(this.glob())) {
-      await this.addRoute(src);
-    }
-
-    return this.routes;
-  }
-
-  isRoute(src: string) {
-    return Boolean(micromatch(src as any, this.glob())?.length);
-  }
-
-  toPath(src: string) {
-    throw new Error("Not implemented");
-  }
-
-  toRoute(src: string): Route | undefined {
-    let path = this.toPath(src);
-
-    if (path === undefined) return;
-
-    const [_, exports] = analyzeModule(src);
-
-    if (!exports.find(e => e.n === "default")) {
-      console.warn("No default export", src);
-    }
-
-    return {
-      $component: {
-        src: src,
-        pick: ["default", "$css"],
-      },
-      path,
-      // filePath: src
-    };
-  }
-
-  /**
-   * To be attached by vite plugin to the vite dev server
-   */
-  update = undefined;
-
-  _addRoute(route: Route) {
-    const idx = this.routes.findIndex(r => r.path === route.path);
-    if (idx >= 0) this.routes.splice(idx, 1);
-    this.routes.push(route);
-
-    return idx >= 0;
-  }
-
-  async addRoute(src: string) {
-    src = normalizePath(src);
-    if (this.isRoute(src)) {
-      try {
-        const route = this.toRoute(src);
-        if (route) {
-          this._addRoute(route);
-          this.reload(route.path, "add");
-        }
-      } catch (e) {
-        console.error(e);
-      }
-    }
-  }
-
-  reload(route: string, type: "update" | "remove" | "add") {
-    this.dispatchEvent(
-      new CustomEvent("reload", {
-        detail: {
-          route,
-          type,
-        },
-      }),
-    );
-  }
-
-  async updateRoute(src_: string) {
-    const src = normalizePath(src_);
-    if (this.isRoute(src)) {
-      try {
-        const route = this.toRoute(src);
-        if (route) {
-          const updated = this._addRoute(route);
-          this.reload(route.path, updated ? "update" : "add");
-        } else {
-          this.removeRoute(src_);
-        }
-      } catch (e) {
-        console.error(e);
-      }
-      // this.update?.();
-    }
-  }
-
-  removeRoute(src: string) {
-    src = normalizePath(src);
-    if (this.isRoute(src)) {
-      const path = this.toPath(src);
-      if (path === undefined) {
-        return;
-      }
-
-      const idx = this.routes.findIndex(r => r.path === path);
-      if (idx === -1) return;
-
-      this.routes.splice(idx, 1);
-      this.reload(path, "remove");
-    }
-  }
-
-  on(type: string, cb: (evt: RouterEvent) => void) {
-    this.addEventListener(type, cb as any);
-    return () => this.removeEventListener(type, cb as any);
-  }
-
-  buildRoutesPromise?: Promise<any[]>;
-
-  async getRoutes() {
-    if (!this.buildRoutesPromise) {
-      this.buildRoutesPromise = this.buildRoutes();
-    }
-    await this.buildRoutesPromise;
-    return this.routes;
-  }
-}

package/src/config/fs-routes/tree-shake.ts

@@ -1,324 +0,0 @@
-// All credit for this work goes to the amazing Next.js team.
-// https://github.com/vercel/next.js/blob/canary/packages/next/build/babel/plugins/next-ssg-transform.ts
-// This is adapted to work with routeData functions. It can be run in two modes, one which preserves the routeData and the Component in the same file, and one which creates a
-
-import type * as Babel from "@babel/core";
-import type { NodePath, PluginObj, PluginPass } from "@babel/core";
-import type { Binding } from "@babel/traverse";
-import { basename } from "pathe";
-import type { Plugin } from "vite";
-
-type State = Omit<PluginPass, "opts"> & {
-  opts: { pick: string[] };
-  refs: Set<any>;
-  done: boolean;
-};
-
-function treeShakeTransform({ types: t }: typeof Babel): PluginObj<State> {
-  function getIdentifier(path: any) {
-    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: any) {
-    const b: Binding | undefined = ident.scope.getBinding(ident.node.name);
-    if (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: any, state: any) {
-    const ident = getIdentifier(path);
-    if (ident && ident.node && isIdentifierReferenced(ident)) {
-      state.refs.add(ident);
-    }
-  }
-  function markImport(path: any, state: any) {
-    const local = path.get("local");
-    if (isIdentifierReferenced(local)) {
-      state.refs.add(local);
-    }
-  }
-
-  return {
-    visitor: {
-      Program: {
-        enter(path, state) {
-          state.refs = new Set();
-          state.done = false;
-          path.traverse(
-            {
-              VariableDeclarator(variablePath, variableState: any) {
-                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") as Array<NodePath>;
-                  properties.forEach(p => {
-                    const local = p.get(
-                      p.node.type === "ObjectProperty"
-                        ? "value"
-                        : p.node.type === "RestElement"
-                          ? "argument"
-                          : (() => {
-                              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") as Array<NodePath>;
-                  elements.forEach(e => {
-                    let local: NodePath<any>;
-                    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);
-                    }
-                  });
-                }
-              },
-              ExportDefaultDeclaration(exportNamedPath) {
-                // if opts.keep is true, we don't remove the routeData export
-                if (state.opts.pick && !state.opts.pick.includes("default")) {
-                  exportNamedPath.remove();
-                }
-              },
-              ExportNamedDeclaration(exportNamedPath) {
-                // if opts.keep is false, we don't remove the routeData export
-                if (!state.opts.pick) {
-                  return;
-                }
-                const specifiers = exportNamedPath.get("specifiers");
-                if (specifiers.length) {
-                  specifiers.forEach(s => {
-                    if (
-                      t.isIdentifier(s.node.exported)
-                        ? s.node.exported.name
-                        : state.opts.pick.includes(s.node.exported.value)
-                    ) {
-                      s.remove();
-                    }
-                  });
-                  if (exportNamedPath.node.specifiers.length < 1) {
-                    exportNamedPath.remove();
-                  }
-                  return;
-                }
-                const decl = exportNamedPath.get("declaration");
-                if (decl == null || decl.node == null) {
-                  return;
-                }
-                switch (decl.node.type) {
-                  case "FunctionDeclaration": {
-                    const name = decl.node.id?.name;
-                    if (name && state.opts.pick && !state.opts.pick.includes(name)) {
-                      exportNamedPath.remove();
-                    }
-                    break;
-                  }
-                  case "VariableDeclaration": {
-                    const inner = decl.get("declarations") as Array<NodePath<any>>;
-                    inner.forEach(d => {
-                      if (d.node.id.type !== "Identifier") {
-                        return;
-                      }
-                      const name = d.node.id.name;
-                      if (state.opts.pick && !state.opts.pick.includes(name)) {
-                        d.remove();
-                      }
-                    });
-                    break;
-                  }
-                  default: {
-                    break;
-                  }
-                }
-              },
-              FunctionDeclaration: markFunction,
-              FunctionExpression: markFunction,
-              ArrowFunctionExpression: markFunction,
-              ImportSpecifier: markImport,
-              ImportDefaultSpecifier: markImport,
-              ImportNamespaceSpecifier: markImport,
-              ImportDeclaration: (path, state) => {
-                if (
-                  path.node.source.value.endsWith(".css") &&
-                  state.opts.pick &&
-                  !state.opts.pick.includes("$css")
-                ) {
-                  path.remove();
-                }
-              },
-            },
-            state,
-          );
-
-          const refs = state.refs;
-          let count = 0;
-          const sweepFunction = (sweepPath: any) => {
-            const ident = getIdentifier(sweepPath);
-            if (ident && ident.node && refs.has(ident) && !isIdentifierReferenced(ident)) {
-              ++count;
-              if (
-                t.isAssignmentExpression(sweepPath.parentPath) ||
-                t.isVariableDeclarator(sweepPath.parentPath)
-              ) {
-                sweepPath.parentPath.remove();
-              } else {
-                sweepPath.remove();
-              }
-            }
-          };
-          function sweepImport(sweepPath: any) {
-            const local = sweepPath.get("local");
-            if (refs.has(local) && !isIdentifierReferenced(local)) {
-              ++count;
-              sweepPath.remove();
-              if (sweepPath.parent.specifiers.length === 0) {
-                sweepPath.parentPath.remove();
-              }
-            }
-          }
-          do {
-            path.scope.crawl();
-            count = 0;
-            path.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"
-                          : (() => {
-                              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: NodePath<any> | undefined;
-                    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);
-        },
-      },
-    },
-  };
-}
-
-export function treeShake(): Plugin {
-  async function transform(id: string, code: string) {
-    const [path, queryString] = id.split("?");
-    const query = new URLSearchParams(queryString);
-    if (query.has("pick")) {
-      const babel = await import("@babel/core");
-      const transformed = await babel.transformAsync(code, {
-        plugins: [[treeShakeTransform, { pick: query.getAll("pick") }]],
-        parserOpts: {
-          plugins: ["jsx", "typescript"],
-        },
-        filename: basename(id),
-        ast: false,
-        sourceMaps: true,
-        configFile: false,
-        babelrc: false,
-        sourceFileName: id,
-      });
-
-      return transformed;
-    }
-  }
-  return {
-    name: "tree-shake",
-    enforce: "pre",
-    async transform(code, id) {
-      const [path, queryString] = id.split("?");
-      if (!path) return;
-      const query = new URLSearchParams(queryString);
-      const ext = path.split(".").pop();
-      if (!ext) return;
-      if (query.has("pick") && ["js", "jsx", "ts", "tsx"].includes(ext)) {
-        const transformed = await transform(id, code);
-        if (!transformed?.code) return;
-
-        return {
-          code: transformed.code,
-          map: transformed.map,
-        };
-      }
-    },
-  };
-}