@benjavicente/router-generator 1.166.24

package/dist/esm/utils.d.ts

@@ -0,0 +1,212 @@
+import { Config, TokenMatcher } from './config.js';
+import { ImportDeclaration, RouteNode } from './types.js';
+/**
+ * Prefix map for O(1) parent route lookups.
+ * Maps each route path prefix to the route node that owns that prefix.
+ * Enables finding longest matching parent without linear search.
+ */
+export declare class RoutePrefixMap {
+    private prefixToRoute;
+    private layoutRoutes;
+    constructor(routes: Array<RouteNode>);
+    /**
+     * Find the longest matching parent route for a given path.
+     * O(k) where k is the number of path segments, not O(n) routes.
+     */
+    findParent(routePath: string): RouteNode | null;
+    /**
+     * Check if a route exists at the given path.
+     */
+    has(routePath: string): boolean;
+    /**
+     * Get a route by exact path.
+     */
+    get(routePath: string): RouteNode | undefined;
+}
+export declare function multiSortBy<T>(arr: Array<T>, accessors?: Array<(item: T) => any>): Array<T>;
+export declare function cleanPath(path: string): string;
+export declare function trimPathLeft(path: string): string;
+export declare function removeLeadingSlash(path: string): string;
+export declare function removeTrailingSlash(s: string): string;
+export declare function determineInitialRoutePath(routePath: string): {
+    routePath: string;
+    originalRoutePath: string;
+};
+/**
+ * Checks if the leading underscore in a segment is escaped.
+ * Returns true if:
+ * - Segment starts with [_] pattern: "[_]layout" -> "_layout"
+ * - Segment is fully escaped and content starts with _: "[_1nd3x]" -> "_1nd3x"
+ */
+export declare function hasEscapedLeadingUnderscore(originalSegment: string): boolean;
+/**
+ * Checks if the trailing underscore in a segment is escaped.
+ * Returns true if:
+ * - Segment ends with [_] pattern: "blog[_]" -> "blog_"
+ * - Segment is fully escaped and content ends with _: "[_r0ut3_]" -> "_r0ut3_"
+ */
+export declare function hasEscapedTrailingUnderscore(originalSegment: string): boolean;
+export declare function replaceBackslash(s: string): string;
+export declare function routePathToVariable(routePath: string): string;
+export declare function removeUnderscores(s?: string): string | undefined;
+/**
+ * Removes underscores from a path, but preserves underscores that were escaped
+ * in the original path (indicated by [_] syntax).
+ *
+ * @param routePath - The path with brackets removed
+ * @param originalPath - The original path that may contain [_] escape sequences
+ * @returns The path with non-escaped underscores removed
+ */
+export declare function removeUnderscoresWithEscape(routePath?: string, originalPath?: string): string;
+/**
+ * Removes layout segments (segments starting with underscore) from a path,
+ * but preserves segments where the underscore was escaped.
+ *
+ * @param routePath - The path with brackets removed
+ * @param originalPath - The original path that may contain [_] escape sequences
+ * @returns The path with non-escaped layout segments removed
+ */
+export declare function removeLayoutSegmentsWithEscape(routePath?: string, originalPath?: string): string;
+/**
+ * Checks if a segment should be treated as a pathless/layout segment.
+ * A segment is pathless if it starts with underscore and the underscore is not escaped.
+ *
+ * @param segment - The segment from routePath (brackets removed)
+ * @param originalSegment - The segment from originalRoutePath (may contain brackets)
+ * @returns true if the segment is pathless (has non-escaped leading underscore)
+ */
+export declare function isSegmentPathless(segment: string, originalSegment: string): boolean;
+export declare function escapeRegExp(s: string): string;
+export declare function createTokenRegex(token: TokenMatcher, opts: {
+    type: 'segment' | 'filename';
+}): RegExp;
+export declare function isBracketWrappedSegment(segment: string): boolean;
+export declare function unwrapBracketWrappedSegment(segment: string): string;
+export declare function removeLeadingUnderscores(s: string, routeToken: string): string;
+export declare function removeTrailingUnderscores(s: string, routeToken: string): string;
+export declare function capitalize(s: string): string;
+export declare function removeExt(d: string, addExtensions?: boolean | string): string;
+/**
+ * This function writes to a file if the content is different.
+ *
+ * @param filepath The path to the file
+ * @param content Original content
+ * @param incomingContent New content
+ * @param callbacks Callbacks to run before and after writing
+ * @returns Whether the file was written
+ */
+export declare function writeIfDifferent(filepath: string, content: string, incomingContent: string, callbacks?: {
+    beforeWrite?: () => void;
+    afterWrite?: () => void;
+}): Promise<boolean>;
+/**
+ * This function formats the source code using the default formatter (Prettier).
+ *
+ * @param source The content to format
+ * @param config The configuration object
+ * @returns The formatted content
+ */
+export declare function format(source: string, config: {
+    quoteStyle: 'single' | 'double';
+    semicolons: boolean;
+}): Promise<string>;
+/**
+ * This function resets the regex index to 0 so that it can be reused
+ * without having to create a new regex object or worry about the last
+ * state when using the global flag.
+ *
+ * @param regex The regex object to reset
+ * @returns
+ */
+export declare function resetRegex(regex: RegExp): void;
+/**
+ * This function checks if a file exists.
+ *
+ * @param file The path to the file
+ * @returns Whether the file exists
+ */
+export declare function checkFileExists(file: string): Promise<boolean>;
+export declare function removeGroups(s: string): string;
+/**
+ * Removes all segments from a given path that start with an underscore ('_').
+ *
+ * @param {string} routePath - The path from which to remove segments. Defaults to '/'.
+ * @returns {string} The path with all underscore-prefixed segments removed.
+ * @example
+ * removeLayoutSegments('/workspace/_auth/foo') // '/workspace/foo'
+ */
+export declare function removeLayoutSegments(routePath?: string): string;
+/**
+ * The `node.path` is used as the `id` in the route definition.
+ * This function checks if the given node has a parent and if so, it determines the correct path for the given node.
+ * @param node - The node to determine the path for.
+ * @returns The correct path for the given node.
+ */
+export declare function determineNodePath(node: RouteNode): string | undefined;
+/**
+ * Removes the last segment from a given path. Segments are considered to be separated by a '/'.
+ *
+ * @param {string} routePath - The path from which to remove the last segment. Defaults to '/'.
+ * @returns {string} The path with the last segment removed.
+ * @example
+ * removeLastSegmentFromPath('/workspace/_auth/foo') // '/workspace/_auth'
+ */
+export declare function removeLastSegmentFromPath(routePath?: string): string;
+/**
+ * Find parent route using RoutePrefixMap for O(k) lookups instead of O(n).
+ */
+export declare function hasParentRoute(prefixMap: RoutePrefixMap, node: RouteNode, routePathToCheck: string | undefined): RouteNode | null;
+/**
+ * Gets the final variable name for a route
+ */
+export declare const getResolvedRouteNodeVariableName: (routeNode: RouteNode) => string;
+/**
+ * Checks if a given RouteNode is valid for augmenting it with typing based on conditions.
+ * Also asserts that the RouteNode is defined.
+ *
+ * @param routeNode - The RouteNode to check.
+ * @returns A boolean indicating whether the RouteNode is defined.
+ */
+export declare function isRouteNodeValidForAugmentation(routeNode?: RouteNode): routeNode is RouteNode;
+/**
+ * Infers the path for use by TS
+ */
+export declare const inferPath: (routeNode: RouteNode) => string;
+/**
+ * Infers the full path for use by TS
+ */
+export declare const inferFullPath: (routeNode: RouteNode) => string;
+/**
+ * Creates a map from fullPath to routeNode
+ */
+export declare const createRouteNodesByFullPath: (routeNodes: Array<RouteNode>) => Map<string, RouteNode>;
+/**
+ * Create a map from 'to' to a routeNode
+ */
+export declare const createRouteNodesByTo: (routeNodes: Array<RouteNode>) => Map<string, RouteNode>;
+/**
+ * Create a map from 'id' to a routeNode
+ */
+export declare const createRouteNodesById: (routeNodes: Array<RouteNode>) => Map<string, RouteNode>;
+/**
+ * Infers to path
+ */
+export declare const inferTo: (routeNode: RouteNode) => string;
+/**
+ * Dedupes branches and index routes
+ */
+export declare const dedupeBranchesAndIndexRoutes: (routes: Array<RouteNode>) => Array<RouteNode>;
+export declare function checkRouteFullPathUniqueness(_routes: Array<RouteNode>, config: Config): void;
+export declare function buildRouteTreeConfig(nodes: Array<RouteNode>, disableTypes: boolean, depth?: number): Array<string>;
+export declare function buildImportString(importDeclaration: ImportDeclaration): string;
+export declare function lowerCaseFirstChar(value: string): string;
+export declare function mergeImportDeclarations(imports: Array<ImportDeclaration>): Array<ImportDeclaration>;
+export declare const findParent: (node: RouteNode | undefined) => string;
+export declare function buildFileRoutesByPathInterface(opts: {
+    routeNodes: Array<RouteNode>;
+    module: string;
+    interfaceName: string;
+    config?: Pick<Config, 'routeToken'>;
+}): string;
+export declare function getImportPath(node: RouteNode, config: Config, generatedRouteTreePath: string): string;
+export declare function getImportForRouteNode(node: RouteNode, config: Config, generatedRouteTreePath: string, root: string): ImportDeclaration;