@askrjs/askr 0.0.48 → 0.0.50

package/dist/router/route.d.ts

@@ -1,149 +1,8 @@
-import { JSXElement } from "../common/jsx.js";
-import { RenderableChild } from "../common/vnode.js";
-import { AccessDecision, AccessDenyDecision, AccessRedirectDecision, GroupHelperOptions, LayoutScopeRecord, PageHelperOptions, PageScopeRecord, ParsedSegment, RegisterRoutesOptions, ResolvedRoute, Route, RouteAuthOptions, RouteComponent, RouteContext, RouteDefinition, RouteHandler, RouteManifest, RouteMatch, RouteOptions, RouteParams, RoutePathParams, RoutePolicy, RouteQuery, RouteRecord, RouteRenderResult, RouteRequestOptions, RouteRequestResult, RouteSnapshot } from "../common/router.js";
-
-//#region src/router/route.d.ts
-type AnyRouteComponent = (...args: any[]) => RenderableChild;
-type RouteComponentParam<TComponent extends AnyRouteComponent> = Parameters<TComponent> extends [] ? unknown : Parameters<TComponent>[0];
-type CompatibleAbsoluteRouteComponent<Path extends string, TComponent extends AnyRouteComponent> = Parameters<TComponent> extends [] ? TComponent : RoutePathParams<Path> extends RouteComponentParam<TComponent> ? TComponent : never;
-type CompatibleRelativeRouteComponent<Path extends string, TComponent extends AnyRouteComponent> = Parameters<TComponent> extends [] ? TComponent : RouteComponentParam<TComponent> extends Record<keyof RoutePathParams<Path>, string> ? TComponent : never;
-type CompatibleRouteComponent<Path extends string, TComponent extends AnyRouteComponent> = Path extends `/${string}` ? CompatibleAbsoluteRouteComponent<Path, TComponent> : CompatibleRelativeRouteComponent<Path, TComponent>;
-type RouteOptionsForComponent<Path extends string, TComponent extends AnyRouteComponent> = Parameters<TComponent> extends [] ? RouteOptions<RoutePathParams<Path>> : RouteComponentParam<TComponent> extends RouteParams ? RouteOptions<RouteComponentParam<TComponent>> : RouteOptions<RoutePathParams<Path>>;
-declare function setServerLocation(url: string | null): void;
-declare function isRoutePathActive(pathOrPaths: string | readonly string[]): boolean;
-declare function computeRouteActivityMatches(pathname: string, options?: {
-  manifest?: RouteManifest;
-  routes?: readonly Route[];
-}): RouteMatch[];
-declare function _setActiveRouteAuthOptions(auth: RouteAuthOptions | undefined): void;
-/**
- * Prevent route registrations after the app has started.
- * Enforced in production; tests may unlock explicitly.
- */
-declare function lockRouteRegistration(): void;
-declare function _lockRouteRegistrationForTests(): void;
-declare function _unlockRouteRegistrationForTests(): void;
-declare function Outlet(): JSXElement;
-/**
- * Snapshot the current in-flight lazy() imports.
- * Boot uses this before clearing route state so manifest-based startup can
- * still await chunks that were kicked off during route module evaluation.
- */
-declare function _snapshotLazy(): Promise<unknown>[];
-/**
- * Declare a code-split route component. The `import()` fires immediately at
- * module evaluation time (creating a bundler split point), and the resolved
- * chunk is guaranteed to be available before the app mounts — so the renderer
- * always receives a plain synchronous function.
- *
- * ```ts
- * registerRoutes(() => {
- *   group({ layout: AppLayout }, () => {
- *     route('/', lazy(() => import('./pages/landing')));
- *     route('/dashboard', lazy(() => import('./pages/dashboard')));
- *   });
- * });
- * ```
- *
- * The module must export the component as its **default** export:
- * ```ts
- * // pages/dashboard.tsx
- * export default function DashboardPage() { … }
- * ```
- */
-declare function lazy<TComponent extends AnyRouteComponent>(factory: () => Promise<{
-  default: TComponent;
-} | TComponent>): TComponent;
-/**
- * Wait for all pending `lazy()` imports to settle.
- * Called automatically by `createSPA` / `hydrateSPA` before mounting.
- */
-declare function _drainLazy(additionalPending?: Iterable<Promise<unknown>>): Promise<void>;
-declare function group(options: GroupHelperOptions, fn: RouteDefinition): void;
-declare function page<const TPath extends string>(path: TPath, Component: RouteComponent<RoutePathParams<TPath>>, fn: RouteDefinition): void;
-declare function page<const TPath extends string, TComponent extends AnyRouteComponent>(path: TPath, Component: CompatibleRouteComponent<TPath, TComponent>, fn: RouteDefinition): void;
-declare function page<const TPath extends string>(path: TPath, Component: RouteComponent<RoutePathParams<TPath>>, options: PageHelperOptions, fn: RouteDefinition): void;
-declare function page<const TPath extends string, TComponent extends AnyRouteComponent>(path: TPath, Component: CompatibleRouteComponent<TPath, TComponent>, options: PageHelperOptions, fn: RouteDefinition): void;
-declare function index(Component: RouteComponent, options?: RouteOptions): void;
-declare function fallback(Component: RouteComponent): void;
-declare function registerRoutes(definition: RouteDefinition, options?: RegisterRoutesOptions): void;
-declare function currentRoute<TParams extends RouteParams = RouteParams>(): RouteSnapshot<TParams>;
-declare function syncCurrentRouteSnapshot(pathname: string, search: string, hash: string, activityMatches?: readonly RouteMatch[]): void;
-/**
- * Register a route.
- *
- * ```ts
- * route('/posts/{slug}', PostPage, {
- *   loader:  ({ params }) => getPost(params.slug),
- *   entries: async () => getPosts().map(p => ({ slug: p.slug })),
- *   title:   'Post',
- *   policies:[requireAuth()],
- * });
- * ```
- */
-declare function route<const TPath extends string>(path: TPath, Component: RouteComponent<RoutePathParams<TPath>>, options?: RouteOptions<RoutePathParams<TPath>>): void;
-declare function route<const TPath extends string, TComponent extends AnyRouteComponent>(path: TPath, Component: CompatibleRouteComponent<TPath, TComponent>, options?: RouteOptionsForComponent<TPath, TComponent>): void;
-/**
- * Return the normalized route manifest built from registered route definitions.
- *
- * Pass this to `createSPA`, `hydrateSPA`, or `renderToString` as the
- * authoritative routing input:
- *
- * ```ts
- * import { getManifest } from '@askrjs/askr/router';
- * await createSPA({ root: '#app', manifest: getManifest() });
- * ```
- */
-declare function getManifest(): RouteManifest;
-/**
- * Internal: apply a pre-built manifest to the runtime stores without running
- * route() again. Called by createSPA / hydrateSPA when a manifest is passed.
- */
-declare function _applyManifest(manifest: RouteManifest): void;
-/**
- * Get all registered routes (flat list, insertion order).
- * Prefer `getManifest()` when metadata (loader, policies, entries) is needed.
- */
-declare function getRoutes(): Route[];
-/** Get routes for a specific namespace. */
-declare function getNamespaceRoutes(namespace: string): Route[];
-/** Unload all routes from a namespace (for MFE unmounting). */
-declare function unloadNamespace(namespace: string): number;
-/** Clear all registered routes and records (testing / boot reset). */
-declare function clearRoutes(): void;
-/**
- * Get all loaded namespaces (MFE identifiers)
- */
-declare function getLoadedNamespaces(): string[];
-/**
- * Resolve a path to a route handler.
- *
- * Hot path: walks the module-level `records[]` array which is kept sorted by
- * rank descending at registration time — so the first `matchSegments` hit is
- * always the most specific match.  No per-call allocations for the common
- * case of purely-static routes.
- */
-declare function resolveRoute(pathname: string): ResolvedRoute | null;
-declare function resolveRouteRequest(target: string, options?: RouteRequestOptions): RouteRequestResult | Promise<RouteRequestResult>;
-/**
- * Resolve a path against an explicit route list (e.g. an SSR per-render
- * context).  When called with the global `routes` array this delegates to
- * the faster `resolveRoute` which uses pre-sorted `records[]`.
- *
- * For externally supplied lists the function:
- *   1. Builds a rank-sorted copy of the list on first call and caches it
- *      in a WeakMap so subsequent resolutions against the same list pay
- *      zero sort cost.
- *   2. Uses pre-parsed `ParsedSegment[]` from a WeakMap cache so no string
- *      splitting or segment parsing occurs on the hot path.
- *   3. Uses a running-best with an early-exit once the sorted list reaches
- *      a rank that cannot beat the current best match.
- */
-declare function resolveRouteFromRoutes(pathname: string, routeList: readonly Route[]): ResolvedRoute | null;
-declare function _resolveRouteMatchFromRoutes(pathname: string, routeList: readonly Route[]): {
-  route: Route;
-  params: Record<string, string>;
-} | null;
-//#endregion
-export { Outlet, clearRoutes, currentRoute, fallback, getManifest, getRoutes, group, index, lazy, page, registerRoutes, route };
-//# sourceMappingURL=route.d.ts.map
+import { AccessDecision, AccessDenyDecision, AccessRedirectDecision, GroupHelperOptions, LayoutScopeRecord, PageHelperOptions, PageScopeRecord, ParsedSegment, RegisterRoutesOptions, ResolvedRoute, Route, RouteAuthOptions, RouteComponent, RouteContext, RouteDefinition, RouteHandler, RouteManifest, RouteMatch, RouteOptions, RouteParams, RoutePathParams, RoutePolicy, RouteQuery, RouteRecord, RouteRegistry, RouteRenderResult, RouteRequestOptions, RouteRequestResult, RouteSnapshot } from "../common/router.js";
+import { fallback, group, index, page, registerRoutes, route } from "./authoring.js";
+import { currentRoute } from "./activity.js";
+import { clearRoutes, createRouteRegistry, getManifest } from "./manifest.js";
+import { getRoutes } from "./store.js";
+import { lazy } from "./lazy.js";
+import { Outlet } from "./rendering.js";
+export { Outlet, clearRoutes, createRouteRegistry, currentRoute, fallback, getManifest, getRoutes, group, index, lazy, page, registerRoutes, route };