@genesislcap/foundation-auth 15.19.3 → 15.19.4

package/dist/dts/routes/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/routes/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAA2B,mBAAmB,EAAS,MAAM,wBAAwB,CAAC;AAC7F,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAS9C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIxC;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,mBAAmB,CAAC,QAAQ,CAAC;IAEzD,OAAO,CAAC,IAAI;IACP,OAAO,CAAC,SAAS;IAChB,OAAO,CAAC,UAAU;IACjB,OAAO,CAAC,WAAW;gBAHlB,IAAI,EAAE,IAAI,EACL,SAAS,EAAE,SAAS,EACnB,UAAU,EAAE,UAAU,EACrB,WAAW,EAAE,WAAW;IAK/C,SAAS;IA0IT,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC;CAGxC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/routes/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAGL,mBAAmB,EAEpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAS9C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAKxC;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,mBAAmB,CAAC,QAAQ,CAAC;IAEzD,OAAO,CAAC,IAAI;IACP,OAAO,CAAC,SAAS;IAChB,OAAO,CAAC,UAAU;IACjB,OAAO,CAAC,WAAW;gBAHlB,IAAI,EAAE,IAAI,EACL,SAAS,EAAE,SAAS,EACnB,UAAU,EAAE,UAAU,EACrB,WAAW,EAAE,WAAW;IAK/C,SAAS;IA0JT,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC;CAGxC"}

package/dist/dts/routes/utils.d.ts

@@ -27,4 +27,20 @@ export declare function navigateTo(route: AuthRoutes | string): void;
  * @public
  */
 export declare function getRoutePath(route: AuthRoutes | string, hostPath?: string): string;
+/**
+ * Whether `pathname` lies outside this micro frontend's host path — i.e. it belongs to the
+ * HOST application, not to us. Only meaningful for a scoping `hostPath` (embedded use);
+ * standalone — `hostPath` empty or `/` — the micro frontend owns every path and this is
+ * always false. Both sides are normalised (leading slash on, trailing slash off) before
+ * comparing, because `hostPath` is commonly configured without a leading slash
+ * (`hostPath: 'auth'` — the documented example) and must scope the same either way.
+ * Matching is on segment boundaries, so `/login-history` is outside `/login` while
+ * `/login/not-found` is in.
+ *
+ * @param pathname - The pathname to classify, typically `location.pathname`.
+ * @param hostPath - The configured host path, e.g. `/login` or `login`.
+ *
+ * @public
+ */
+export declare function isOutsideHostPath(pathname: string, hostPath: string): boolean;
 //# sourceMappingURL=utils.d.ts.map

package/dist/dts/routes/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/routes/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,QAAQ,GAAE,MAA0B,GAAG,OAAO,CAKvE;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,QAGpD;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,QAAQ,GAAE,MAAW,GAAG,MAAM,CAQtF"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/routes/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,QAAQ,GAAE,MAA0B,GAAG,OAAO,CAKvE;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,QAGpD;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,QAAQ,GAAE,MAAW,GAAG,MAAM,CAQtF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAO7E"}

package/dist/dts/routes/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/dts/routes/utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../../src/routes/utils.test.ts"],"names":[],"mappings":""}

package/dist/esm/routes/config.js

@@ -1,7 +1,7 @@
 import { __awaiter, __decorate, __param } from "tslib";
 import { User } from '@genesislcap/foundation-user';
 import { Container } from '@microsoft/fast-foundation';
-import { RouterConfiguration, Route } from '@microsoft/fast-router';
+import { Ignore, RouterConfiguration, Route, } from '@microsoft/fast-router';
 import { AuthConfig } from '../config/config';
 import { defaultLayout } from '../layouts';
 import { logger } from '../utils';
@@ -13,6 +13,7 @@ import { RequestAccount } from './request-account/request-account';
 import { ResetPassword } from './reset-password/reset-password';
 import { AuthRouting } from './routing';
 import { TermsConditions } from './terms-conditions/terms-conditions';
+import { isOutsideHostPath } from './utils';
 import { Verify } from './verify/verify';
 /**
  * Base implementation of a routing used with the Auth class
@@ -117,6 +118,19 @@ let AuthRouterConfig = class AuthRouterConfig extends RouterConfiguration {
          * Example of a FallbackRouteDefinition
          */
         this.routes.fallback(() => {
+            // The router hears every app-wide URL change, so an unmatched path is not necessarily
+            // ours to handle. Embedded in a host application (a non-empty hostPath, e.g. '/login'
+            // inside a react-router app), the host's own routes land in this fallback too — most
+            // visibly right after a successful login, when the host's post-login navigation races
+            // this micro frontend's teardown: an authenticated fallback then rewrote the host's
+            // URL to `<hostPath>/not-found`, and the app was stranded on that poisoned URL at its
+            // next full reload. A path outside the host path is the host application's business —
+            // stand down and navigate nowhere. Standalone (hostPath '') keeps the old behaviour:
+            // this micro frontend owns every path there.
+            if (!this.parent && isOutsideHostPath(location.pathname, this.authConfig.hostPath)) {
+                logger.debug('AuthRouterConfig.routes.fallback. Path outside hostPath, ignoring:', location.pathname);
+                return { command: new Ignore() };
+            }
             this.user.trackPath();
             const result = this.user.isAuthenticated
                 ? { redirect: getRoutePath('not-found') }

package/dist/esm/routes/utils.js

@@ -44,3 +44,34 @@ export function getRoutePath(route, hostPath = '') {
     }
     return hostPath ? `${hostPath}/${route}` : route;
 }
+/**
+ * Whether `pathname` lies outside this micro frontend's host path — i.e. it belongs to the
+ * HOST application, not to us. Only meaningful for a scoping `hostPath` (embedded use);
+ * standalone — `hostPath` empty or `/` — the micro frontend owns every path and this is
+ * always false. Both sides are normalised (leading slash on, trailing slash off) before
+ * comparing, because `hostPath` is commonly configured without a leading slash
+ * (`hostPath: 'auth'` — the documented example) and must scope the same either way.
+ * Matching is on segment boundaries, so `/login-history` is outside `/login` while
+ * `/login/not-found` is in.
+ *
+ * @param pathname - The pathname to classify, typically `location.pathname`.
+ * @param hostPath - The configured host path, e.g. `/login` or `login`.
+ *
+ * @public
+ */
+export function isOutsideHostPath(pathname, hostPath) {
+    const host = normalizePathname(hostPath);
+    if (!host || host === '/') {
+        return false;
+    }
+    const path = normalizePathname(pathname);
+    return path !== host && !path.startsWith(`${host}/`);
+}
+/** Leading slash on, trailing slash off; `''` stays `''` so an unset hostPath keeps meaning "owns everything". */
+function normalizePathname(value) {
+    if (!value) {
+        return '';
+    }
+    const led = value.startsWith('/') ? value : `/${value}`;
+    return led.length > 1 && led.endsWith('/') ? led.slice(0, -1) : led;
+}

package/dist/esm/routes/utils.test.js

@@ -0,0 +1,33 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { isOutsideHostPath } from './utils';
+const Suite = createLogicSuite('isOutsideHostPath');
+Suite('standalone (empty hostPath) owns every path', () => {
+    assert.is(isOutsideHostPath('/anything', ''), false);
+    assert.is(isOutsideHostPath('/', ''), false);
+});
+Suite('the host path itself and its sub routes are inside', () => {
+    assert.is(isOutsideHostPath('/login', '/login'), false);
+    assert.is(isOutsideHostPath('/login/not-found', '/login'), false);
+    assert.is(isOutsideHostPath('/login/reset-password', '/login'), false);
+});
+Suite('the host application routes are outside', () => {
+    // The teardown race this classifier exists for: the host app navigates to its own route
+    // right after login, and the fallback must NOT rewrite it to `<hostPath>/not-found`.
+    assert.is(isOutsideHostPath('/home', '/login'), true);
+    assert.is(isOutsideHostPath('/', '/login'), true);
+});
+Suite('matching is on segment boundaries, not string prefixes', () => {
+    assert.is(isOutsideHostPath('/login-history', '/login'), true);
+});
+Suite('hostPath and pathname are normalized (leading/trailing slashes)', () => {
+    // The documented configuration style omits the leading slash (`hostPath: 'auth'`) — it
+    // must scope identically to `/auth`, or the fallback would ignore its own routes.
+    assert.is(isOutsideHostPath('/login', 'login'), false);
+    assert.is(isOutsideHostPath('/login/', '/login'), false);
+    assert.is(isOutsideHostPath('/login/not-found', 'login/'), false);
+    assert.is(isOutsideHostPath('/home', 'login'), true);
+});
+Suite('a root hostPath owns every path, like an empty one', () => {
+    assert.is(isOutsideHostPath('/anything', '/'), false);
+});
+Suite.run();

package/dist/foundation-auth.api.json

@@ -11286,6 +11286,67 @@
           ],
           "name": "isNackEntity"
         },
+        {
+          "kind": "Function",
+          "canonicalReference": "@genesislcap/foundation-auth!isOutsideHostPath:function(1)",
+          "docComment": "/**\n * Whether `pathname` lies outside this micro frontend's host path — i.e. it belongs to the HOST application, not to us. Only meaningful for a scoping `hostPath` (embedded use); standalone — `hostPath` empty or `/` — the micro frontend owns every path and this is always false. Both sides are normalised (leading slash on, trailing slash off) before comparing, because `hostPath` is commonly configured without a leading slash (`hostPath: 'auth'` — the documented example) and must scope the same either way. Matching is on segment boundaries, so `/login-history` is outside `/login` while `/login/not-found` is in.\n *\n * @param pathname - The pathname to classify, typically `location.pathname`.\n *\n * @param hostPath - The configured host path, e.g. `/login` or `login`.\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function isOutsideHostPath(pathname: "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": ", hostPath: "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "boolean"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/routes/utils.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 5,
+            "endIndex": 6
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "pathname",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            },
+            {
+              "parameterName": "hostPath",
+              "parameterTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "isOutsideHostPath"
+        },
         {
           "kind": "Function",
           "canonicalReference": "@genesislcap/foundation-auth!isQueryParams:function(1)",

package/dist/foundation-auth.d.ts

@@ -2143,6 +2143,23 @@ export declare function isNackDTO(dto: unknown): dto is NACK;
  */
 export declare function isNackEntity(entity: unknown): entity is Nack;
 
+/**
+ * Whether `pathname` lies outside this micro frontend's host path — i.e. it belongs to the
+ * HOST application, not to us. Only meaningful for a scoping `hostPath` (embedded use);
+ * standalone — `hostPath` empty or `/` — the micro frontend owns every path and this is
+ * always false. Both sides are normalised (leading slash on, trailing slash off) before
+ * comparing, because `hostPath` is commonly configured without a leading slash
+ * (`hostPath: 'auth'` — the documented example) and must scope the same either way.
+ * Matching is on segment boundaries, so `/login-history` is outside `/login` while
+ * `/login/not-found` is in.
+ *
+ * @param pathname - The pathname to classify, typically `location.pathname`.
+ * @param hostPath - The configured host path, e.g. `/login` or `login`.
+ *
+ * @public
+ */
+export declare function isOutsideHostPath(pathname: string, hostPath: string): boolean;
+
 /**
  * isQueryParams.
  * @param params - Potential QueryParams.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/foundation-auth",
   "description": "Genesis Foundation Auth",
-  "version": "15.19.3",
+  "version": "15.19.4",
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
   "types": "dist/foundation-auth.d.ts",
@@ -134,25 +134,25 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "15.19.3",
-    "@genesislcap/genx": "15.19.3",
-    "@genesislcap/rollup-builder": "15.19.3",
-    "@genesislcap/ts-builder": "15.19.3",
-    "@genesislcap/uvu-playwright-builder": "15.19.3",
-    "@genesislcap/vite-builder": "15.19.3",
-    "@genesislcap/webpack-builder": "15.19.3"
+    "@genesislcap/foundation-testing": "15.19.4",
+    "@genesislcap/genx": "15.19.4",
+    "@genesislcap/rollup-builder": "15.19.4",
+    "@genesislcap/ts-builder": "15.19.4",
+    "@genesislcap/uvu-playwright-builder": "15.19.4",
+    "@genesislcap/vite-builder": "15.19.4",
+    "@genesislcap/webpack-builder": "15.19.4"
   },
   "dependencies": {
-    "@genesislcap/foundation-comms": "15.19.3",
-    "@genesislcap/foundation-events": "15.19.3",
-    "@genesislcap/foundation-i18n": "15.19.3",
-    "@genesislcap/foundation-logger": "15.19.3",
-    "@genesislcap/foundation-state-machine": "15.19.3",
-    "@genesislcap/foundation-store": "15.19.3",
-    "@genesislcap/foundation-ui": "15.19.3",
-    "@genesislcap/foundation-user": "15.19.3",
-    "@genesislcap/foundation-utils": "15.19.3",
-    "@genesislcap/foundation-zero": "15.19.3",
+    "@genesislcap/foundation-comms": "15.19.4",
+    "@genesislcap/foundation-events": "15.19.4",
+    "@genesislcap/foundation-i18n": "15.19.4",
+    "@genesislcap/foundation-logger": "15.19.4",
+    "@genesislcap/foundation-state-machine": "15.19.4",
+    "@genesislcap/foundation-store": "15.19.4",
+    "@genesislcap/foundation-ui": "15.19.4",
+    "@genesislcap/foundation-user": "15.19.4",
+    "@genesislcap/foundation-utils": "15.19.4",
+    "@genesislcap/foundation-zero": "15.19.4",
     "@microsoft/fast-components": "2.30.6",
     "@microsoft/fast-element": "1.14.0",
     "@microsoft/fast-foundation": "2.50.0",