@opencxh/domain 1.137.0 → 1.142.0

package/dist/platform/manifest.d.ts

@@ -138,6 +138,14 @@ export interface AppManifest<TSDK = any> {
      * Paths will be automatically prefixed with `/apps/{appName}`.
      */
     routes?: RouteDefinition[];
+    /**
+     * Root path the app's `public: true` routes are mounted under, e.g. `/help`.
+     *
+     * Only cosmetic: without it a public route keeps the `/apps/{appName}`
+     * prefix and works exactly the same. It exists because a help centre or a
+     * status page is a URL customers see and link to.
+     */
+    publicBasePath?: string;
     /** An array of menu items provided by this application. */
     menu?: MenuItem[];
     /** An array of translations provided by this application. */

package/dist/platform/routing.d.ts

@@ -8,9 +8,78 @@ export interface RouteDefinition {
     resource: string;
     /** If true, the path must match exactly. */
     exact?: boolean;
+    /**
+     * Readable without a session. The shell skips its bounce to the login screen
+     * for these paths and renders them without any chrome.
+     *
+     * This says nothing about the data behind the page: every server route is
+     * still authenticated unless it opts out with `{ authenticated: false }`.
+     */
+    public?: boolean;
 }
 export interface NamespacedRouteDefinition extends RouteDefinition {
     appName: string;
     /** The full, namespaced path, e.g., /apps/my-app/settings */
     absolutePath: string;
 }
+/**
+ * The app that owns the login screen. Landing there is never a destination —
+ * it is where you get sent when you have no session yet.
+ */
+export declare const AUTH_APP_NAME = "auth";
+/**
+ * The app that owns this path, or null when the path names no app.
+ *
+ * Tolerates a missing path on purpose: one caller is a router bridge that has
+ * not been bound yet, and it asks from inside an RxJS subscriber — where a
+ * thrown TypeError takes the subscription down without a word.
+ */
+export declare function appNameFromPath(path: string | null | undefined): string | null;
+/**
+ * Does this landing path say where the user wanted to go?
+ *
+ * Asked at startup by everything that would otherwise send the user somewhere
+ * of its own choosing. It has to be one shared answer: the shell and the module
+ * loader both used to decide this, and the loader's "go to the default app"
+ * simply ran last and overwrote whatever URL you had opened.
+ *
+ * `/wake` counts — the service worker lands there with a provider in the query
+ * and `WakeRoute` routes onward itself.
+ */
+export declare function isDeepLink(path: string | null | undefined): boolean;
+/** Turn a route pattern with `:param` segments into an exact-match regex. */
+export declare function pathToRegex(path: string): RegExp;
+/** Read the `:param` values out of a concrete path, given the pattern it matched. */
+export declare function extractParams(pattern: string, actualPath: string): Record<string, string>;
+/** The shape of a manifest this module needs; keeps it free of the manifest module. */
+export interface PublicRouteSource {
+    name: string;
+    /**
+     * Root path the app's public routes hang under, e.g. `/help`. Absent means
+     * they keep the normal `/apps/{name}` prefix — public, just not pretty.
+     */
+    publicBasePath?: string;
+    routes?: RouteDefinition[];
+}
+export interface PublicRoutePattern {
+    appName: string;
+    resource: string;
+    /** Absolute pattern, e.g. `/help/:hcSlug/:locale`. */
+    pattern: string;
+}
+export interface PublicRouteMatch extends PublicRoutePattern {
+    params: Record<string, string>;
+}
+/** Where an app's public routes are mounted. */
+export declare function publicBasePathFor(app: PublicRouteSource): string;
+/** Every public route across the installed apps, as absolute patterns. */
+export declare function publicRoutePatterns(apps: Iterable<PublicRouteSource>): PublicRoutePattern[];
+/**
+ * The public route this path lands on, or null.
+ *
+ * Most specific pattern wins, so registration order never decides which page a
+ * URL opens.
+ */
+export declare function matchPublicRoute(path: string | null | undefined, patterns: readonly PublicRoutePattern[]): PublicRouteMatch | null;
+/** Does this path resolve to a page that may be read without a session? */
+export declare function isPublicPath(path: string | null | undefined, patterns: readonly PublicRoutePattern[]): boolean;

package/dist/platform/routing.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/platform/sdk.d.ts

@@ -22,7 +22,16 @@ export interface InternalSDK<LocalServices extends ServiceMap = {}, TranslationK
         invoke<R = any>(options: InvokeOptions): Promise<R>;
     };
     readonly router: {
+        /** Relative to the app's own `/apps/{appName}` prefix. */
         navigate(path: string, options?: any): void;
+        /**
+         * Straight to a shell path, no prefix.
+         *
+         * For the app's `public: true` routes: those hang off the manifest's
+         * `publicBasePath` (`/help/…`), so the app prefix would point at a page
+         * that does not exist.
+         */
+        navigateAbsolute(path: string, options?: any): void;
         currentPath(): string;
         path$: Observable<string>;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencxh/domain",
-  "version": "1.137.0",
+  "version": "1.142.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",