sync: release/11.14.0 (sba-internal → sba-mint)

.github/CODEOWNERS

@@ -0,0 +1,13 @@
+# This is a comment
+
+# Each line is a file pattern followed by one or more owners
+
+# These owners will be the default owners for everything in
+
+# the repo. Unless a later match takes precedence
+
+# @dev will be requested for
+
+# review when someone opens a pull request
+
+#*       @Product/sbacodeowners

.github/workflows/deploy-private.yml

@@ -1,4 +1,4 @@
-name: Build and deploy the Mint documentation on Github Enterprise
+name: Deploy Docs on Github Enterprise
 
 on:
   #push:

.github/workflows/deploy-public.yml

@@ -1,5 +1,5 @@
 # Sample workflow for building and deploying a Jekyll site to GitHub Pages
-name: Build the Mint documentation on Github.com
+name: Deploy Docs on Github.com
 
 on:
   # Runs on pushes targeting the default branch

.github/workflows/pull-request.yml

@@ -21,6 +21,13 @@ jobs:
       uses: actions/setup-node@v4
       with:
         node-version: '22.x'
+    - name: Get branch name
+      run: |
+           if [ -z $GITHUB_HEAD_REF ]; then
+             echo "Current branch:$GITHUB_REF_NAME"
+           else
+             echo "Current branch:$GITHUB_HEAD_REF"
+           fi
     - run: npm ci
     - run: npm run build --if-present
       env:

.github/workflows/release-version.yml

@@ -0,0 +1,55 @@
+name: "Release: Bump Version"
+
+on:
+  pull_request:
+    types: [closed]
+    branches:
+      - dev/11
+      - release/*
+
+jobs:
+  bump-and-tag:
+    # On ne s'exécute que si la PR est fusionnée
+    if: github.event.pull_request.merged == true
+    runs-on: self-hosted
+
+    # Indispensable sur Enterprise pour autoriser l'écriture
+    permissions:
+      contents: write
+      pull-requests: read
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          # Retrieves the target branch (base) of the PR
+          ref: ${{ github.event.pull_request.base.ref }}
+          token: ${{ secrets.RELEASE_BOT_TOKEN || secrets.GITHUB_TOKEN }}
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Configure Git Bot
+        run: |
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+
+      - name: Bump Version
+        id: npm_bump
+        run: |
+          # We dynamically retrieve the name of the target branch
+          TARGET_BRANCH=${{ github.event.pull_request.base.ref }}
+
+          echo "Merge detected on : $TARGET_BRANCH"
+
+          # Increment
+          npm version patch -m "chore(release): %s [skip ci]"
+
+      - name: Push Changes
+        run: |
+          # We push the commit for package.json and the Git tag to GitHub Enterprise
+          git push origin $TARGET_BRANCH --follow-tags

.oxlintrc.json

@@ -1,11 +1,14 @@
 {
   "$schema": "./node_modules/oxlint/configuration_schema.json",
-  "plugins": ["import", "eslint", "typescript"],
+  "plugins": [
+    "typescript",
+    "unicorn",
+    "oxc"
+  ],
   "categories": {
     "correctness" : "warn"
   },
   "rules": {
-    "eslint-no-unused-vars": "error",
     "typescript/no-floating-promises": "warn",
     "typescript/no-unsafe-assignment": "warn",
   },

.vscode/settings.json

@@ -3,9 +3,37 @@
     "*.scss": "tailwindcss",
     "*.css": "tailwindcss"
   },
+  "tailwindCSS.lint.suggestCanonicalClasses": "warning",
+  "tailwindCSS.classFunctions": ["cva", "tw", "clsx", "tw\\.[a-z-]+"],
+  "tailwindCSS.classAttributes": ["class", "className", "[ngClass]", "class:list", "[class]", "tv", "cn", "cva", "variant"],
+  "tailwindCSS.experimental.classRegex": [
+    ["cva\\(([^)]*)\\)", "[\"'`]([^\"'`]*).*?[\"'`]"],
+    ["tv\\(([^)]*)\\)", "{?\\s?[\\w].*:\\s*?[\"'`]([^\"'`]*).*?,?\\s?}?"],
+    ["cn\\(([^;]*)[\\);]", "[`'\"`]([^'\"`;]*)[`'\"`]"],
+    ":\\s*?[\"'`]([^\"'`]*).*?,",
+    ["host:\\s*{([\\s\\S]*?)}", "\\s?[\\w].*:\\s*?[\"'`]([^\"'`]*).*?,?\\s?"]
+  ],
   "github-enterprise.uri": "https://github.sinequa.com",
   "explorer.fileNesting.enabled": true,
   "explorer.fileNesting.patterns": {
     "proxy.conf.json": "proxy.conf.json, proxy.conf.*.json"
-  }
+  },
+  "editor.codeActionsOnSave": {
+    "source.fixAll.oxc": "explicit"
+  },
+  "oxc.typeAware": true,
+  "oxc.fmt.configPath": ".oxfmtrc.json",
+  "editor.defaultFormatter": "oxc.oxc-vscode",
+  "editor.formatOnSave": false,
+  "[html]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+    "editor.formatOnSave": true
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "oxc.oxc-vscode",
+    "editor.formatOnSave": true
+  },
+  "gitstash.explorer.display.fileSorting": "tree",
+  "oxc.enable.oxlint": true,
+  "oxc.enable.oxfmt": true
 }

docusaurus/docs/atomic-angular/components/drawer/drawer.md

@@ -1,9 +1,14 @@
 ---
 title: DrawerComponent
+sidebar_class_name: deprecated
 ---
 
 This component represents a drawer that can be opened and extended. Each instance of the DrawerComponent has its own drawer service to handle its state and link it to the drawer stack.
 
+:::warning
+ The `DrawerComponent` is marked as deprecated and will be removed in future releases. It is recommended to use alternative drawer implementations for new projects.
+:::
+
 **Selector:** `app-drawer`
 
 **Standalone:** true

docusaurus/docs/mint/configurations/custom-reuse-strategy.mdx

@@ -0,0 +1,120 @@
+---
+title: Custom Route Reuse Strategy
+sidebar_class_name: new
+---
+
+By default, Angular destroys a component's instance when the user navigates away from its route and re-creates it from scratch when they navigate back. This means any in-memory state (conversation history, scroll position, loaded data, etc.) is lost on every navigation.
+
+Mint ships a `CustomReuseStrategy` that overrides this behaviour for specific routes: their component instances are **detached** from the DOM and kept in memory instead of destroyed, then **re-attached** transparently when the user returns.
+
+## How it works
+
+Angular's `RouteReuseStrategy` interface exposes five hooks that are called at different points of the navigation lifecycle. `CustomReuseStrategy` implements all five:
+
+```
+Navigate away                         Navigate back
+─────────────────────────────         ─────────────────────────
+shouldDetach?  ──yes──► store()       shouldAttach?  ──yes──► retrieve()
+               ──no──►  destroy                      ──no──►  create fresh
+```
+
+| Hook | Role |
+|---|---|
+| `shouldDetach(route)` | Returns `true` when `route.data["reuse"]` is truthy. Only those routes are kept in memory. |
+| `store(route, handle)` | Saves the live component handle into an internal map keyed by `route.routeConfig.path`. |
+| `shouldAttach(route)` | Returns `true` when a saved handle exists for the route's path. |
+| `retrieve(route)` | Returns the saved handle so Angular can re-attach it. |
+| `shouldReuseRoute(future, curr)` | Standard Angular behaviour: reuses the route if the route config object is the same reference (same URL, no full reload). |
+
+### Source
+
+```typescript title="src/config/custom-reuse-strategy.ts"
+export class CustomReuseStrategy implements RouteReuseStrategy {
+  private handlers: { [key: string]: DetachedRouteHandle } = {};
+
+  shouldDetach(route: ActivatedRouteSnapshot): boolean {
+    return !!route.data["reuse"];
+  }
+
+  store(route: ActivatedRouteSnapshot, handle: DetachedRouteHandle): void {
+    if (route.routeConfig?.path) {
+      this.handlers[route.routeConfig.path] = handle;
+    }
+  }
+
+  shouldAttach(route: ActivatedRouteSnapshot): boolean {
+    return !!route.routeConfig?.path && !!this.handlers[route.routeConfig.path];
+  }
+
+  retrieve(route: ActivatedRouteSnapshot): DetachedRouteHandle | null {
+    if (!route.routeConfig?.path) return null;
+    return this.handlers[route.routeConfig.path];
+  }
+
+  shouldReuseRoute(
+    future: ActivatedRouteSnapshot,
+    curr: ActivatedRouteSnapshot,
+  ): boolean {
+    return future.routeConfig === curr.routeConfig;
+  }
+}
+```
+
+## Registration
+
+The strategy is registered as an Angular provider in `src/app/app.config.ts`, replacing Angular's default implementation globally:
+
+```typescript title="src/app/app.config.ts"
+import { RouteReuseStrategy } from '@angular/router';
+import { CustomReuseStrategy } from '@config/custom-reuse-strategy';
+
+export const appConfig: ApplicationConfig = {
+  providers: [
+    // ...
+    { provide: RouteReuseStrategy, useClass: CustomReuseStrategy },
+  ],
+};
+```
+
+## Opting a route in
+
+Reuse is **opt-in per route**. Add `data: { reuse: true }` to any route definition you want to preserve:
+
+```typescript title="src/app/routes.ts"
+{
+  path: 'assistant',
+  loadComponent: () => import('./pages/assistant/assistant.layout')
+    .then(m => m.AssistantLayoutComponent),
+  canActivate: [AuthGuard()],
+  resolve: { queryName: queryNameResolver },
+  // highlight-next-line
+  data: { reuse: true }, // component instance is kept alive across navigations
+},
+```
+
+Routes **without** `data: { reuse: true }` behave exactly as they would with Angular's default strategy.
+
+:::info Why the assistant?
+The `/assistant` route is the only one currently marked for reuse. Keeping its component alive means the conversation history, streaming state, and scroll position are preserved when the user temporarily switches to another page (e.g. a search result) and then comes back.
+:::
+
+## Adding reuse to another route
+
+1. Open `src/app/routes.ts`.
+2. Add `data: { reuse: true }` to the route you want to preserve.
+
+```typescript
+{
+  path: 'my-feature',
+  loadComponent: () => import('./pages/my-feature/my-feature.component')
+    .then(m => m.MyFeatureComponent),
+  canActivate: [AuthGuard()],
+  data: { reuse: true },
+},
+```
+
+That is all — no other change is needed. The `CustomReuseStrategy` picks up the flag automatically.
+
+:::warning Memory considerations
+Preserved components stay in memory for the **entire session**. Avoid marking heavy or rarely-visited routes as reusable without a good reason, as their memory footprint accumulates over the lifetime of the session.
+:::