@open-rlb/ng-app 3.1.110 → 3.1.112

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-rlb/ng-app",
-  "version": "3.1.110",
+  "version": "3.1.112",
   "peerDependencies": {
     "@angular/common": ">=21.0.0 <22.0.0",
     "@angular/core": ">=21.0.0 <22.0.0",
@@ -21,6 +21,10 @@
   "dependencies": {
     "tslib": "^2.8.1"
   },
+  "schematics": "./schematics/collection.json",
+  "ng-add": {
+    "save": "dependencies"
+  },
   "sideEffects": false,
   "module": "fesm2022/open-rlb-ng-app.mjs",
   "typings": "types/open-rlb-ng-app.d.ts",
@@ -33,5 +37,9 @@
       "default": "./fesm2022/open-rlb-ng-app.mjs"
     }
   },
-  "type": "module"
+  "type": "module",
+  "files": [
+    "**/*",
+    "schematics/package.json"
+  ]
 }

package/schematics/collection.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "../../../../node_modules/@angular-devkit/schematics/collection-schema.json",
+  "schematics": {
+    "ng-add": {
+      "description": "Add @open-rlb/ng-app to an Angular project: install peer dependencies, register Bootstrap styles, and scaffold a runnable application shell (environment, providers, app shell, routes, i18n).",
+      "factory": "./ng-add/index#ngAdd",
+      "schema": "./ng-add/schema.json"
+    }
+  }
+}

package/schematics/ng-add/claude-skills/rlb-app-apps/SKILL.md

@@ -0,0 +1,110 @@
+---
+name: rlb-app-apps
+description: The @open-rlb/ng-app multi-app orchestration — the AppInfo/AppDescriber model, AppsService (the runtime engine), domain + ACL filtering of apps, current-app selection from the route, and root/deep-link redirect rules. Use when registering apps, building an app hub/selector, controlling which app is "current", or debugging why an app isn't shown or selected.
+---
+
+# @open-rlb/ng-app — Apps & Orchestration
+
+`@open-rlb/ng-app` is a **multi-app shell**: a single host hosts one or more logical "apps", each
+described by an `AppInfo`. **`AppsService`** is the runtime engine that filters those apps by
+domain and ACL, selects the current app from the active route, and applies redirect rules. It is
+exported from the public API and **eagerly bootstrapped** by `provideRlbConfig`
+(`provideAppInitializer(() => inject(AppsService))`), so it runs as soon as the app starts.
+
+## The app model — `AppInfo`
+
+An app is registered via `provideApp(appDescriber)` (`AppDescriber.info` is an `AppInfo`). Fields
+that drive runtime behavior:
+
+| Field | Drives |
+|---|---|
+| `type` | App kind/category (e.g. `'app'`); used in `finalizeApp`/route matching. |
+| `enabled` | Whether the app participates. |
+| `core` / `settings` | `AppDetails` — `{ title, description, url, icon, auth }`. `core.url` is the app's landing route and the redirect target. |
+| `viewMode` | `'app'` \| `'settings'` — how the shell frames the app. |
+| `routes` | Route path strings owned by the app; matched against the active URL to select it. |
+| `domains` | If set, the app only appears/activates on those `window.location.hostname`s (domain gating). |
+| `actions` | ACL action names; the app is hidden unless the user holds a matching resource action (ACL gating). |
+| `autoRedirectOnRootEnabled` | At root with multiple apps, redirect to this app's `core.url`. |
+| `data` | Arbitrary payload; carries the ACL `businessIdKey` / `resourceIdKey` values used for permission checks. |
+
+```typescript
+export const appDescriber: AppDescriber = {
+  info: {
+    type: 'app',
+    enabled: true,
+    actions: ['sysadmin'],
+    core: { title: 'My App', description: '', url: '/home', icon: 'bi bi-house', auth: true },
+  },
+  routes,   // Angular Routes; flattened paths are stored on RLB_APPS
+};
+```
+
+## Registration → runtime lifecycle
+
+```
+provideApp(appDescriber)            register the AppInfo into RLB_APPS (multi)
+  → RLB_INIT_PROVIDER.finalizeApps  ACL hook dispatches AppContextActions.finalizeApp → apps gain an `id`
+  → AppsService.apps (computed)     filters finalized apps by domain + ACL resources/actions
+  → router listener (NavigationEnd) matches the route → selects currentApp + applies redirects
+```
+
+This is the "AppsService orchestration" step of the auth pipeline
+(`checkAuthMultiple → resourcesByUser → finalizeApp → AppsService orchestration`). See
+[[rlb-app-auth-acl]] for the ACL hook and [[rlb-app-config]] for `provideApp`/`RLB_APPS`.
+
+## Reading apps from a component
+
+Inject `AppsService` and read its signals (zoneless — use signals, never zone.js):
+
+```typescript
+private apps = inject(AppsService);
+
+readonly visibleApps = this.apps.apps;        // signal: domain- + ACL-filtered AppInfo[]
+readonly current = this.apps.currentApp;      // signal: AppInfo | null
+readonly currentId = this.apps.currentAppId;  // signal: string | undefined
+
+canEdit = this.apps.checkPermissionInCurrentApp('catalog-editor'); // ACL in current app
+this.apps.selectApp(app, 'app', '/home');     // manually select (the app hub/selector uses this)
+```
+
+The built-in app/settings selector pages (`pages/apps/*`, `pages/settings/*`) render
+`apps()` and call `selectApp(...)`.
+
+## Current-app selection & redirect rules
+
+On each `NavigationEnd`, `AppsService` resolves the active route and applies (in order):
+
+1. **Single app at root** → auto-redirect to that app's `core.url`.
+2. **Multiple apps at root** → show the app hub (`currentApp` is `null`), unless an app has
+   `autoRedirectOnRootEnabled` (then redirect to it).
+3. **Deep link** (non-root) → select the app whose `routes`/`core.url` matches the path.
+
+Selection waits until apps are **finalized** (every app has an `id`); until then `currentApp`
+stays unresolved.
+
+## ACL on initial deep-link — `findAppForPath`
+
+Because `currentApp` isn't selected until `NavigationEnd` fires, `permissionGuard` handles the
+first navigation specially: if no `currentApp` yet, it calls
+`appsService.findAppForPath(path)` to locate the owning app from the URL, then
+`checkPermissionForApp(app, action)`. After that, it uses `checkPermissionInCurrentApp(action)`.
+The `*roles` directive also reads `checkPermissionInCurrentApp` (re-runs reactively). See
+[[rlb-app-auth-acl]].
+
+## Multi-provider auth by domain
+
+`AppsService.initAuthProviders()` picks the OIDC provider at startup: if one provider, use it; if
+several, match by `provider.domains` against the current hostname. Multiple matches (or none) log
+a warning and leave the provider unset — give each provider a distinct `domains` entry.
+
+## Gotchas
+
+- **Apps must be finalized** (have an `id`) before selection resolves — driven by the ACL init
+  hook; an empty `apps()` usually means ACL/finalize hasn't run yet.
+- **`currentApp()` is `null` at root** in multi-app (hub) mode — that's expected, not an error.
+- **Domain gating uses `window.location.hostname`** — `localhost` won't match production
+  `domains`; include `localhost` (or omit `domains`) for local dev.
+- Don't re-run `selectApp` redundantly — it no-ops when the id + viewMode are unchanged.
+
+Related: [[rlb-app-config]], [[rlb-app-auth-acl]], [[rlb-app-shell]], [[rlb-app-store]].

package/schematics/ng-add/claude-skills/rlb-app-auth-acl/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: rlb-app-auth-acl
+description: Authentication (OIDC) and authorization (ACL) in @open-rlb/ng-app — OAuth provider config, the oauthGuard and permissionGuard route guards, the *roles structural directive, and the RLB_INIT_PROVIDER ACL startup hook. Use when securing routes/UI or configuring login.
+---
+
+# @open-rlb/ng-app — Auth & ACL
+
+Authentication is OIDC via `angular-auth-oidc-client`; authorization is action-based ACL resolved from the backend on startup.
+
+## Configuring auth
+
+In `environment.ts` under `auth`:
+
+```typescript
+auth: {
+  protocol: 'oauth',
+  storage: 'localStorage',            // 'cookies' | 'localStorage' | 'sessionStorage'
+  interceptor: 'oauth-code-ep',       // attach tokens to endpoint calls
+  allowedUrls: ['https://api.example.com'],
+  enableCompanyInterceptor: true,
+  providers: [{
+    configId: 'default',
+    authority: 'https://login.example.com/realms/your-realm',
+    clientId: 'your-client-id',
+    redirectUrl: 'http://localhost:4200',
+    postLogoutRedirectUri: 'http://localhost:4200',
+    scope: 'openid profile offline_access',
+    acl: { endpointKey: 'http-gateway', path: 'admin/acl/resources' },  // where to fetch ACL
+  }],
+}
+```
+
+The startup pipeline is `checkAuthMultiple → resourcesByUser → finalizeApp → AppsService orchestration` (wired by `provideRlbConfig`). The final step — filtering apps by domain/ACL and selecting the current app from the route — is handled by `AppsService`; see [[rlb-app-apps]].
+
+## Guarding routes
+
+```typescript
+import { oauthGuard, permissionGuard } from '@open-rlb/ng-app';
+
+{ path: 'account', component: AccountComponent, canActivate: [oauthGuard] },
+{ path: 'admin', component: AdminComponent, canActivate: [permissionGuard], data: { action: 'sysadmin' } },
+```
+
+- `oauthGuard` — requires an authenticated session.
+- `permissionGuard` — requires the ACL action named in `route.data.action`.
+
+## Guarding UI
+
+The `*roles` structural directive shows content only if the user holds the action:
+
+```html
+<button *roles="'sysadmin'">Admin only</button>
+```
+
+(`RlbAppModule` provides the directive.)
+
+## ACL startup hook — RLB_INIT_PROVIDER
+
+Implement `RlbInitProvider` to map the user's `UserResource[]` into app instances:
+
+```typescript
+@Injectable()
+export class AppInitAclProvider implements RlbInitProvider {
+  async finalizeApps(resources: UserResource[], store: Store<BaseState>, acl: AclConfiguration) {
+    resources.forEach(company => company.resources.forEach(res => {
+      store.dispatch(AppContextActions.finalizeApp({
+        appType: 'app',
+        appId: `app-${res.resourceId}`,
+        data: {
+          title: res.friendlyName,
+          [acl.businessIdKey]: company.companyId,
+          [acl.resourceIdKey]: res.resourceId,
+        },
+      }));
+    }));
+  }
+}
+```
+
+Register it: `{ provide: RLB_INIT_PROVIDER, useClass: AppInitAclProvider }`. The action names in `appDescriber.info.actions` must match the ACL actions your backend returns.
+
+Related: [[rlb-app-apps]], [[rlb-app-config]], [[rlb-app-store]], [[rlb-app-shell]].

package/schematics/ng-add/claude-skills/rlb-app-config/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: rlb-app-config
+description: Configuration and bootstrap of an app built on @open-rlb/ng-app — the ProjectConfiguration/environment shape, provideRlbConfig(), provideApp(), the AppDescriber, and the RLB_INIT_PROVIDER startup hook. Use when wiring up app.config.ts, editing environment.ts, or changing app metadata/routes.
+---
+
+# @open-rlb/ng-app — Configuration & Bootstrap
+
+You are an expert in bootstrapping an Angular application on the **@open-rlb/ng-app** library. A host app is intentionally thin: it supplies a `ProjectConfiguration` (the environment), an `AppDescriber`, and an optional ACL init provider, then the library wires the store, router, auth, HTTP, i18n and service worker.
+
+## app.config.ts — the three building blocks
+
+```typescript
+export const appConfig: ApplicationConfig = {
+  providers: [
+    provideRlbConfig(environment),   // store + router + auth + i18n + http + SW + registries
+    provideApp(appDescriber),        // app identity, ACL actions, routes, custom providers
+    { provide: RLB_INIT_PROVIDER, useClass: AppInitAclProvider }, // optional startup ACL mapping
+    provideZonelessChangeDetection(),
+  ],
+};
+```
+
+- `provideRlbConfig(environment)` is the only place the library config is read. It internally calls `provideRlbBootstrap()` (so do NOT call it again), registers the four NgRx feature slices, the default routes derived from `environment.pages`, OIDC auth (`provideRlbCodeBrowserOAuth(env.auth)`), i18n (`provideRlbI18n(env.i18n)`), `provideHttpClient(withInterceptorsFromDi())`, the service worker, and the built-in modal/toast registries.
+- `provideApp(appDescriber)` registers `RLB_APPS` (multi), adds `appDescriber.routes` via `provideRouter`, and spreads any `appDescriber.providers`. At runtime those registered apps are filtered and selected by `AppsService` — see [[rlb-app-apps]].
+
+## environment.ts — ProjectConfiguration
+
+`ProjectConfiguration = IConfiguration & { production: boolean }`. Sections:
+
+| Key | Purpose |
+|---|---|
+| `environment` | app metadata: `appTitle`, `appLogo`, `baseUrl`, `errorDialogName`, `logLevel`, `pwaUpdateEnabled`, `navbarDisabled` |
+| `auth` | OIDC: `protocol: 'oauth'`, `storage`, `interceptor`, `allowedUrls`, `providers[]` (per-provider `authority`/`clientId`/`redirectUrl`/`acl`) |
+| `i18n` | `availableLangs`, `defaultLanguage`, `useLanguageBrowser`, `storeSelectedLanguage`, `cookieStoreName` |
+| `pages` | named route paths for standard pages (notFound, forbidden, support, …) |
+| `endpoints` | named HTTP/WS backends (`{ baseUrl, healthPath, auth, wss }`) referenced by key (e.g. `http-gateway`) |
+| `acl` | `businessIdKey`, `resourceIdKey`, `interceptorMapping` |
+
+Inject any slice with the tokens: `RLB_CFG`, `RLB_CFG_ENV`, `RLB_CFG_I18N`, `RLB_CFG_PAGES`, `RLB_CFG_ACL`, `RLB_CFG_CMS`.
+
+## AppDescriber
+
+```typescript
+export const appDescriber: AppDescriber = {
+  info: {
+    type: 'app',
+    enabled: true,
+    actions: ['sysadmin', ...],   // ACL action names this app understands
+    core: { title, description, url, icon, auth: true },
+    settings: { title, description, url, icon, auth: true },
+  },
+  routes,                          // Angular Routes; flattened paths are registered with RLB_APPS
+  providers: [ /* optional: e.g. RLB_APP_NAVCOMP overrides */ ],
+};
+```
+
+## RLB_INIT_PROVIDER
+
+A class implementing `RlbInitProvider.finalizeApps(resources, store, acl)`. It runs after authentication, turning the user's ACL `UserResource[]` into app instances via `AppContextActions.finalizeApp(...)`. Optional — omit the provider if you don't drive apps from ACL. See [[rlb-app-auth-acl]].
+
+## Common gotchas
+
+- The app is **zoneless** — never rely on zone.js; use signals.
+- `appLogo`/i18n files live under `src/assets`; ensure `assets` includes `src/assets` in `angular.json`.
+- The service worker is `enabled: !isDevMode()`, so it's off under `ng serve`. For production builds, configure `ngsw-config.json` (e.g. `ng add @angular/pwa`).
+
+Related: [[rlb-app-apps]], [[rlb-app-shell]], [[rlb-app-store]], [[rlb-app-auth-acl]].

package/schematics/ng-add/claude-skills/rlb-app-shell/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: rlb-app-shell
+description: The @open-rlb/ng-app application shell — <rlb-app-container>, navbar/sidebar configuration via NgRx actions, language selection, and custom navbar item components (RLB_APP_NAVCOMP). Use when building or customizing the app layout/chrome.
+---
+
+# @open-rlb/ng-app — Application Shell
+
+The shell renders the full app chrome (navbar, sidebar, modal/toast containers, routed content). The host `AppComponent` is thin: it mounts `<rlb-app-container>` and dispatches store actions to configure visibility and items.
+
+## Mounting the shell
+
+```typescript
+@Component({
+  selector: 'app-root',
+  imports: [RlbAppModule],
+  template: `
+    <rlb-app-container
+      modal-container-id="modal-c-1"
+      toast-container-ids="toast-c-1"
+    />`,
+})
+export class AppComponent { /* dispatch config in constructor */ }
+```
+
+`RlbAppModule` aggregates the library's standalone components/directives/pipes; import it wherever you use shell elements (`rlb-app-container`, `rlb-navbar-item`, the `*roles` directive, etc.).
+
+## Configuring navbar & sidebar (NgRx actions)
+
+Dispatch in `AppComponent`'s constructor:
+
+```typescript
+this.store.dispatch(NavbarActions.setLoginVisible({ visible: true }));
+this.store.dispatch(NavbarActions.setSettingsVisible({ visible: true }));
+this.store.dispatch(NavbarActions.setAppsVisible({ visible: true }));
+
+this.store.dispatch(SidebarActions.setAppsVisible({ visible: true }));
+this.store.dispatch(SidebarActions.setItems({
+  items: [
+    { title: 'Menu' },                                   // section header
+    { label: 'Home', url: '/', icon: 'bi bi-house' },
+    { label: 'Profile', url: '/profile', icon: 'bi bi-person', badgeCounter: 3 },
+    { label: 'Links', icon: 'bi bi-link', items: [       // nested
+      { label: 'GitHub', icon: 'bi bi-github', externalUrl: 'https://github.com' },
+    ]},
+  ],
+}));
+
+this.store.dispatch(AppContextActions.setSupportedLanguages({ supportedLanguages: ['en', 'it'] }));
+```
+
+Sidebar item shape: `{ title }` (header) or `{ label, url? | externalUrl?, icon?, badgeCounter?, items? }`.
+
+## Custom navbar item components
+
+Override navbar slots by providing `RLB_APP_NAVCOMP` (via `appDescriber.providers`):
+
+```typescript
+{
+  provide: RLB_APP_NAVCOMP,
+  useValue: {
+    left:  [{ component: MyNavItemComponent, name: 'my-item' }],
+    right: [{ component: MyNavItemComponent, name: 'my-item' }],
+  },
+}
+```
+
+Icons are Bootstrap Icons (`bi bi-*`), available because the shell registers `bootstrap-icons.css`.
+
+Related: [[rlb-app-config]], [[rlb-app-apps]], [[rlb-app-store]], [[rlb-app-auth-acl]].

package/schematics/ng-add/claude-skills/rlb-app-store/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: rlb-app-store
+description: The @open-rlb/ng-app NgRx store — the auth, appContext, navbars, and sidebars feature slices, their action groups, and reading state with signals. Use when dispatching actions or selecting app/auth/navbar/sidebar state.
+---
+
+# @open-rlb/ng-app — Store (NgRx)
+
+The library owns the store. `provideRlbConfig()` registers four feature slices; the host app dispatches actions and selects state. Prefer **signals** (`store.selectSignal`, `toSignal`) over the `async` pipe — the app is zoneless.
+
+## Feature slices
+
+| Feature key | Purpose | Actions |
+|---|---|---|
+| `auth` | login/logout, user info, token | `AuthActions` |
+| `app` (`appContextFeatureKey`) | current app, apps list, theme, language | `AppContextActions` |
+| `navbars` | navbar items, layout mode, visibility | `NavbarActions` |
+| `sidebars` | sidebar items (nested), visibility | `SidebarActions` |
+
+`BaseState` is the combined root state (`AclState & AuthState & SidebarState & NavbarState & AppState`). Type your store as `Store<BaseState>`.
+
+## Reading state
+
+```typescript
+private store = inject(Store<BaseState>);
+
+// signal (preferred)
+currentApp = this.store.selectSignal(s => s[appContextFeatureKey].currentApp);
+
+// or observable
+this.store.select(s => s[appContextFeatureKey].apps).subscribe(/* … */);
+```
+
+## Common actions
+
+```typescript
+AppContextActions.setSupportedLanguages({ supportedLanguages: ['en', 'it'] });
+AppContextActions.finalizeApp({ appType, appId, data });   // register an app instance (see ACL)
+
+NavbarActions.setLoginVisible({ visible });
+NavbarActions.setSettingsVisible({ visible });
+NavbarActions.setAppsVisible({ visible });
+
+SidebarActions.setItems({ items });
+SidebarActions.setAppsVisible({ visible });
+```
+
+`*Internal` action groups (e.g. `AppContextActionsInternal`) are driven by the library's effects — don't dispatch them from app code.
+
+Related: [[rlb-app-shell]], [[rlb-app-apps]], [[rlb-app-auth-acl]], [[rlb-app-config]].

package/schematics/ng-add/files/app/app-init-acl.provider.ts.template

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import { Store } from '@ngrx/store';
+import {
+  AclConfiguration,
+  AppContextActions,
+  appContextFeatureKey,
+  BaseState,
+  RlbInitProvider,
+  UserResource,
+} from '@open-rlb/ng-app';
+
+/**
+ * Runs once on startup after authentication: turns the user's ACL resources into
+ * app instances via `finalizeApp`. This is an example — adapt `appType`/`appId`
+ * and the data mapping to your domain.
+ */
+@Injectable()
+export class AppInitAclProvider implements RlbInitProvider {
+  async finalizeApps(
+    resources: UserResource[],
+    store: Store<BaseState>,
+    acl: AclConfiguration,
+  ): Promise<void> {
+    if (!resources || resources.length === 0) {
+      return;
+    }
+
+    const currentApps = store.selectSignal(state => state[appContextFeatureKey].apps)();
+
+    resources.forEach(company => {
+      company.resources.forEach(res => {
+        const appId = `app-${res.resourceId}`;
+        if (currentApps.findIndex(app => app.id === appId) === -1) {
+          const appData = {
+            title: res.friendlyName,
+            appName: res.friendlyName,
+            [acl.businessIdKey]: company.companyId,
+            [acl.resourceIdKey]: res.resourceId,
+          };
+
+          store.dispatch(
+            AppContextActions.finalizeApp({
+              appType: 'app',
+              appId,
+              data: appData,
+            }),
+          );
+        } else {
+          console.warn(`[AppInitAclProvider]: appId ${appId} exists already, skip finalize`);
+        }
+      });
+    });
+  }
+}

package/schematics/ng-add/files/app/app.component.ts.template

@@ -0,0 +1,44 @@
+import { Component } from '@angular/core';
+import { Store } from '@ngrx/store';
+import {
+  AppContextActions,
+  BaseState,
+  NavbarActions,
+  RlbAppModule,
+  SidebarActions,
+} from '@open-rlb/ng-app';
+
+@Component({
+  selector: 'app-root',
+  imports: [RlbAppModule],
+  template: `
+    <rlb-app-container
+      modal-container-id="modal-c-1"
+      toast-container-ids="toast-c-1"
+    />
+  `,
+})
+export class AppComponent {
+  constructor(public store: Store<BaseState>) {
+    this.store.dispatch(
+      AppContextActions.setSupportedLanguages({
+        supportedLanguages: ['en', 'it'],
+      }),
+    );
+
+    this.store.dispatch(NavbarActions.setLoginVisible({ visible: true }));
+    this.store.dispatch(NavbarActions.setSettingsVisible({ visible: true }));
+    this.store.dispatch(NavbarActions.setAppsVisible({ visible: true }));
+    this.store.dispatch(SidebarActions.setLoginVisible({ visible: false }));
+    this.store.dispatch(SidebarActions.setSettingsVisible({ visible: false }));
+    this.store.dispatch(SidebarActions.setAppsVisible({ visible: true }));
+    this.store.dispatch(
+      SidebarActions.setItems({
+        items: [
+          { title: 'Menu' },
+          { label: 'Home', url: '/', icon: 'bi bi-house' },
+        ],
+      }),
+    );
+  }
+}

package/schematics/ng-add/files/app/app.config.ts.template

@@ -0,0 +1,17 @@
+import { ApplicationConfig, provideZonelessChangeDetection } from '@angular/core';
+import { provideApp, provideRlbConfig, RLB_INIT_PROVIDER } from '@open-rlb/ng-app';
+import { environment } from '../environments/environment';
+import { appDescriber } from './app.describer';
+import { AppInitAclProvider } from './app-init-acl.provider';
+
+export const appConfig: ApplicationConfig = {
+  providers: [
+    provideRlbConfig(environment),
+    provideApp(appDescriber),
+    {
+      provide: RLB_INIT_PROVIDER,
+      useClass: AppInitAclProvider,
+    },
+    provideZonelessChangeDetection(),
+  ],
+};

package/schematics/ng-add/files/app/app.describer.ts.template

@@ -0,0 +1,30 @@
+import { AppDescriber } from '@open-rlb/ng-app';
+import { routes } from './app.routes';
+
+/**
+ * Describes this app's identity and capabilities to @open-rlb/ng-app.
+ * `actions` are the ACL action names this app understands (used by `permissionGuard`
+ * and the `*roles` directive). Adjust `info` and `actions` to match your app.
+ */
+export const appDescriber: AppDescriber = {
+  info: {
+    type: 'app',
+    enabled: true,
+    actions: ['sysadmin'],
+    core: {
+      title: 'Home',
+      description: 'Application home',
+      url: 'home',
+      icon: 'bi bi-house',
+      auth: true,
+    },
+    settings: {
+      title: 'Settings',
+      description: 'Application settings',
+      url: 'settings',
+      icon: 'bi bi-gear',
+      auth: true,
+    },
+  },
+  routes,
+};

package/schematics/ng-add/files/app/app.routes.ts.template

@@ -0,0 +1,21 @@
+import { Routes } from '@angular/router';
+import { HomeComponent } from './home/home.component';
+
+export const routes: Routes = [
+  {
+    path: '',
+    data: { template: 'app' },
+    component: HomeComponent,
+  },
+  {
+    path: 'home',
+    component: HomeComponent,
+  },
+  // Example of a route guarded by an ACL action:
+  // {
+  //   path: 'protected',
+  //   component: ProtectedComponent,
+  //   canActivate: [permissionGuard],
+  //   data: { action: 'sysadmin' },
+  // },
+];

package/schematics/ng-add/files/app/home/home.component.html.template

@@ -0,0 +1,4 @@
+<div class="container py-4">
+  <h1>{{ title }}</h1>
+  <p>Your @open-rlb/ng-app shell is running. Edit <code>src/app/home/home.component.html</code> to get started.</p>
+</div>

package/schematics/ng-add/files/app/home/home.component.ts.template

@@ -0,0 +1,13 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { RlbAppModule } from '@open-rlb/ng-app';
+
+@Component({
+  selector: 'app-home',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  imports: [CommonModule, RlbAppModule],
+  templateUrl: './home.component.html',
+})
+export class HomeComponent {
+  title = 'Home';
+}