@maketribe/ms-app 3.0.1 → 3.0.4

package/src/utils.ts

@@ -0,0 +1,233 @@
+import { encodePath } from "ufo";
+
+enum SegmentParserState {
+  initial,
+  static,
+  dynamic,
+  optional,
+  catchall,
+}
+
+interface ScannedFile {
+  path: string;
+  module: any;
+}
+
+enum SegmentTokenType {
+  static,
+  dynamic,
+  optional,
+  catchall,
+}
+
+interface SegmentToken {
+  type: SegmentTokenType;
+  value: string;
+}
+
+export function generateRoutesFromFiles(files: ScannedFile[]) {
+  const routes: any[] = [];
+
+  for (const file of files) {
+    const segments = file.path.split("/");
+
+    const route: Record<string, any> = {
+      meta: {},
+      ...file.module.mkRoute,
+      key: "",
+      path: "",
+      component: async () => file.module,
+      children: [],
+    };
+
+    let parent = routes;
+
+    for (const segment of segments) {
+      const tokens = parseSegment(segment);
+      const segmentName = tokens.map(({ value }) => value).join("");
+
+      route.key += (route.key && "/") + segmentName;
+
+      const path = route.path + getRoutePath(tokens).replace(/\/index$/, "/");
+      const child = parent.find(
+        (parentRoute) =>
+          parentRoute.key === route.key && parentRoute.path === path
+      );
+
+      if (child && child.children) {
+        parent = child.children;
+        route.path = "";
+      } else if (segmentName === "index" && !route.path) {
+        route.path += "/";
+      } else if (segmentName !== "index") {
+        route.path += getRoutePath(tokens);
+      }
+    }
+
+    route.path = file.module.mkRoute.path || route.path;
+
+    parent.push(route);
+  }
+
+  return prepareRoutes(routes);
+}
+
+function getRoutePath(tokens: SegmentToken[]) {
+  return tokens.reduce((path, token) => {
+    return (
+      path +
+      (token.type === SegmentTokenType.optional
+        ? `:${token.value}?`
+        : token.type === SegmentTokenType.dynamic
+        ? `:${token.value}()`
+        : token.type === SegmentTokenType.catchall
+        ? `:${token.value}(.*)*`
+        : encodePath(token.value).replace(/:/g, "\\:"))
+    );
+  }, "/");
+}
+
+const PARAM_CHAR_RE = /[\w\d_.]/;
+
+function parseSegment(segment: string) {
+  let state: SegmentParserState = SegmentParserState.initial;
+
+  let i = 0;
+
+  let buffer = "";
+  const tokens: SegmentToken[] = [];
+
+  function consumeBuffer() {
+    if (!buffer) {
+      return;
+    }
+
+    if (state === SegmentParserState.initial) {
+      throw new Error("错误的状态");
+    }
+
+    tokens.push({
+      type:
+        state === SegmentParserState.static
+          ? SegmentTokenType.static
+          : state === SegmentParserState.dynamic
+          ? SegmentTokenType.dynamic
+          : state === SegmentParserState.optional
+          ? SegmentTokenType.optional
+          : SegmentTokenType.catchall,
+      value: buffer,
+    });
+
+    buffer = "";
+  }
+
+  while (i < segment.length) {
+    const c = segment[i];
+
+    switch (state) {
+      case SegmentParserState.initial:
+        buffer = "";
+
+        if (c === "[") {
+          state = SegmentParserState.dynamic;
+        } else {
+          i--;
+          state = SegmentParserState.static;
+        }
+
+        break;
+      case SegmentParserState.static:
+        if (c === "[") {
+          consumeBuffer();
+          state = SegmentParserState.dynamic;
+        } else {
+          buffer += c;
+        }
+        break;
+      case SegmentParserState.catchall:
+      case SegmentParserState.dynamic:
+      case SegmentParserState.optional:
+        if (buffer === "...") {
+          buffer = "";
+          state = SegmentParserState.catchall;
+        }
+
+        if (c === "[" && state === SegmentParserState.dynamic) {
+          state = SegmentParserState.optional;
+        }
+
+        if (
+          c === "]" &&
+          (state !== SegmentParserState.optional || segment[i - 1] === "]")
+        ) {
+          if (!buffer) {
+            throw new Error("空参数");
+          }
+          consumeBuffer();
+          state = SegmentParserState.initial;
+        } else if (PARAM_CHAR_RE.test(c)) {
+          buffer += c;
+        }
+        break;
+    }
+
+    i++;
+  }
+
+  if (state === SegmentParserState.dynamic) {
+    throw new Error(`Unfinished param "${buffer}"`);
+  }
+
+  consumeBuffer();
+
+  return tokens;
+}
+
+function findRouteByKey(key: string, routes: any[]): any | undefined {
+  for (const route of routes) {
+    if (route.key === key) {
+      return route;
+    }
+  }
+  return findRouteByKey(key, routes);
+}
+
+function prepareRoutes(routes: any[], parent?: any, keys = new Set<string>()) {
+  for (const route of routes) {
+    // Remove -index
+    if (route.key) {
+      route.key = route.key.replace(/\/index$/, "").replace(/\//g, "-");
+
+      if (keys.has(route.key)) {
+        const existingRoute = findRouteByKey(route.key, routes);
+        const extra = existingRoute?.name
+          ? `is the same as \`${existingRoute.file}\``
+          : "is a duplicate";
+        console.warn(
+          `Route name generated for \`${route.file}\` ${extra}. You may wish to set a custom name using \`definePageMeta\` within the page file.`
+        );
+      }
+    }
+
+    route.path = route.path.replace(/\/\//g, "/");
+
+    // Remove leading / if children route
+    if (parent && route.path.startsWith("/")) {
+      route.path = route.path.slice(1);
+    }
+
+    if (route.children?.length) {
+      route.children = prepareRoutes(route.children, route, keys);
+    }
+
+    if (route.children?.find((childRoute: any) => childRoute.path === "")) {
+      delete route.key;
+    }
+
+    if (route.key) {
+      keys.add(route.key);
+    }
+  }
+
+  return routes;
+}