@scania-nl/tegel-angular-extensions 0.0.7 → 0.0.9

package/esm2022/lib/components/tae-date-time-picker/tae-date-time-picker.utils.mjs

@@ -0,0 +1,148 @@
+/**
+ * Parses an ISO date segment (`YYYY-MM-DD`) into local date parts.
+ * @param datePart ISO date segment to parse.
+ * @returns Parsed date parts or `null` when invalid.
+ */
+export function parseDatePartsFromIso(datePart) {
+    if (!datePart)
+        return null;
+    // Split on the ISO separator and validate expected parts.
+    const parts = datePart.split('-');
+    if (parts.length !== 3)
+        return null;
+    // Convert to numbers and normalize month to 0-based.
+    const year = parseInt(parts[0], 10);
+    const month = parseInt(parts[1], 10) - 1;
+    const day = parseInt(parts[2], 10);
+    // Reject invalid dates early.
+    if (!isValidDateParts(year, month, day))
+        return null;
+    return { year, month, day };
+}
+/**
+ * Validates date parts (0-based month) against calendar limits.
+ * @param year Full year value.
+ * @param month Zero-based month.
+ * @param day Day of month (1-based).
+ * @returns `true` when the date exists in the calendar.
+ */
+export function isValidDateParts(year, month, day) {
+    if (!Number.isFinite(year) ||
+        !Number.isFinite(month) ||
+        !Number.isFinite(day)) {
+        return false;
+    }
+    // Basic range checks for month/day.
+    if (month < 0 || month > 11 || day < 1)
+        return false;
+    // Ensure the day exists in the target month/year.
+    const lastDay = new Date(year, month + 1, 0).getDate();
+    return day <= lastDay;
+}
+/**
+ * Formats an ISO date/datetime value into `dd-MM-YYYY` display format.
+ * @param value ISO date or datetime string.
+ * @param mode Formatting mode (`date` or `datetime`).
+ * @returns Display-friendly string.
+ */
+export function formatDisplayDateTime(value, mode) {
+    if (!value) {
+        return '';
+    }
+    if (mode === 'time') {
+        return value;
+    }
+    if (mode === 'datetime') {
+        const [datePart, timePart] = value.split('T');
+        if (!datePart)
+            return value;
+        // Expect ISO `YYYY-MM-DD` for the date portion.
+        const dateParts = datePart.split('-');
+        if (dateParts.length !== 3)
+            return value;
+        const [year, month, day] = dateParts;
+        const formattedDate = `${day}-${month}-${year}`;
+        // Preserve time if present.
+        if (timePart) {
+            return `${formattedDate} ${timePart}`;
+        }
+        return formattedDate;
+    }
+    // Date-only mode expects ISO `YYYY-MM-DD`.
+    const parts = value.split('-');
+    if (parts.length !== 3)
+        return value;
+    const [year, month, day] = parts;
+    return `${day}-${month}-${year}`;
+}
+/**
+ * Builds a 6x7 calendar grid for the provided month/year.
+ * Includes trailing days from previous/next months to fill the grid.
+ * @param currentYear Target year.
+ * @param currentMonth Target month (0-based).
+ * @param selected Selected date parts or `null`.
+ * @param today Reference date for the "today" flag.
+ * @returns Calendar day entries for rendering.
+ */
+export function buildCalendarDays(currentYear, currentMonth, selected, today) {
+    const calendarDays = [];
+    const firstDay = new Date(currentYear, currentMonth, 1);
+    const lastDay = new Date(currentYear, currentMonth + 1, 0);
+    const todayYear = today.getFullYear();
+    const todayMonth = today.getMonth();
+    const todayDay = today.getDate();
+    // Get the day of week for the first day (0 = Sunday, we want Monday = 0).
+    let startDay = firstDay.getDay() - 1;
+    if (startDay < 0)
+        startDay = 6;
+    // Helper to flag if a given day is selected.
+    const isSelected = (day, month, year) => !!selected &&
+        selected.day === day &&
+        selected.month === month &&
+        selected.year === year;
+    // Previous month days
+    const prevMonthLastDay = new Date(currentYear, currentMonth, 0).getDate();
+    const prevMonth = currentMonth === 0 ? 11 : currentMonth - 1;
+    const prevYear = currentMonth === 0 ? currentYear - 1 : currentYear;
+    for (let i = startDay - 1; i >= 0; i--) {
+        const day = prevMonthLastDay - i;
+        calendarDays.push({
+            date: day,
+            month: prevMonth,
+            year: prevYear,
+            isCurrentMonth: false,
+            isToday: false,
+            isSelected: isSelected(day, prevMonth, prevYear),
+        });
+    }
+    // Current month days
+    for (let day = 1; day <= lastDay.getDate(); day++) {
+        const isToday = day === todayDay &&
+            currentMonth === todayMonth &&
+            currentYear === todayYear;
+        calendarDays.push({
+            date: day,
+            month: currentMonth,
+            year: currentYear,
+            isCurrentMonth: true,
+            isToday,
+            isSelected: isSelected(day, currentMonth, currentYear),
+        });
+    }
+    // Next month days to fill the grid (6 rows x 7 days = 42).
+    const remainingDays = 42 - calendarDays.length;
+    const nextMonth = currentMonth === 11 ? 0 : currentMonth + 1;
+    const nextYear = currentMonth === 11 ? currentYear + 1 : currentYear;
+    for (let day = 1; day <= remainingDays; day++) {
+        calendarDays.push({
+            date: day,
+            month: nextMonth,
+            year: nextYear,
+            isCurrentMonth: false,
+            isToday: false,
+            isSelected: isSelected(day, nextMonth, nextYear),
+        });
+    }
+    return calendarDays;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tae-date-time-picker.utils.js","sourceRoot":"","sources":["../../../../../../../libs/tegel-angular-extensions/src/lib/components/tae-date-time-picker/tae-date-time-picker.utils.ts"],"names":[],"mappings":"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","sourcesContent":["/** Represents a normalized date in local time (0-based month). */\nexport type DateParts = {\n  year: number;\n  month: number;\n  day: number;\n};\n\n/** A single day entry used by the calendar grid renderer. */\nexport type CalendarDay = {\n  date: number;\n  month: number;\n  year: number;\n  isCurrentMonth: boolean;\n  isToday: boolean;\n  isSelected: boolean;\n};\n\n/**\n * Parses an ISO date segment (`YYYY-MM-DD`) into local date parts.\n * @param datePart ISO date segment to parse.\n * @returns Parsed date parts or `null` when invalid.\n */\nexport function parseDatePartsFromIso(datePart: string): DateParts | null {\n  if (!datePart) return null;\n  // Split on the ISO separator and validate expected parts.\n  const parts = datePart.split('-');\n  if (parts.length !== 3) return null;\n\n  // Convert to numbers and normalize month to 0-based.\n  const year = parseInt(parts[0], 10);\n  const month = parseInt(parts[1], 10) - 1;\n  const day = parseInt(parts[2], 10);\n\n  // Reject invalid dates early.\n  if (!isValidDateParts(year, month, day)) return null;\n\n  return { year, month, day };\n}\n\n/**\n * Validates date parts (0-based month) against calendar limits.\n * @param year Full year value.\n * @param month Zero-based month.\n * @param day Day of month (1-based).\n * @returns `true` when the date exists in the calendar.\n */\nexport function isValidDateParts(\n  year: number,\n  month: number,\n  day: number,\n): boolean {\n  if (\n    !Number.isFinite(year) ||\n    !Number.isFinite(month) ||\n    !Number.isFinite(day)\n  ) {\n    return false;\n  }\n  // Basic range checks for month/day.\n  if (month < 0 || month > 11 || day < 1) return false;\n  // Ensure the day exists in the target month/year.\n  const lastDay = new Date(year, month + 1, 0).getDate();\n  return day <= lastDay;\n}\n\n/**\n * Formats an ISO date/datetime value into `dd-MM-YYYY` display format.\n * @param value ISO date or datetime string.\n * @param mode Formatting mode (`date` or `datetime`).\n * @returns Display-friendly string.\n */\nexport function formatDisplayDateTime(\n  value: string,\n  mode: 'date' | 'datetime' | 'time',\n): string {\n  if (!value) {\n    return '';\n  }\n\n  if (mode === 'time') {\n    return value;\n  }\n\n  if (mode === 'datetime') {\n    const [datePart, timePart] = value.split('T');\n    if (!datePart) return value;\n\n    // Expect ISO `YYYY-MM-DD` for the date portion.\n    const dateParts = datePart.split('-');\n    if (dateParts.length !== 3) return value;\n\n    const [year, month, day] = dateParts;\n    const formattedDate = `${day}-${month}-${year}`;\n\n    // Preserve time if present.\n    if (timePart) {\n      return `${formattedDate} ${timePart}`;\n    }\n    return formattedDate;\n  }\n\n  // Date-only mode expects ISO `YYYY-MM-DD`.\n  const parts = value.split('-');\n  if (parts.length !== 3) return value;\n\n  const [year, month, day] = parts;\n  return `${day}-${month}-${year}`;\n}\n\n/**\n * Builds a 6x7 calendar grid for the provided month/year.\n * Includes trailing days from previous/next months to fill the grid.\n * @param currentYear Target year.\n * @param currentMonth Target month (0-based).\n * @param selected Selected date parts or `null`.\n * @param today Reference date for the \"today\" flag.\n * @returns Calendar day entries for rendering.\n */\nexport function buildCalendarDays(\n  currentYear: number,\n  currentMonth: number,\n  selected: DateParts | null,\n  today: Date,\n): CalendarDay[] {\n  const calendarDays: CalendarDay[] = [];\n\n  const firstDay = new Date(currentYear, currentMonth, 1);\n  const lastDay = new Date(currentYear, currentMonth + 1, 0);\n  const todayYear = today.getFullYear();\n  const todayMonth = today.getMonth();\n  const todayDay = today.getDate();\n\n  // Get the day of week for the first day (0 = Sunday, we want Monday = 0).\n  let startDay = firstDay.getDay() - 1;\n  if (startDay < 0) startDay = 6;\n\n  // Helper to flag if a given day is selected.\n  const isSelected = (day: number, month: number, year: number): boolean =>\n    !!selected &&\n    selected.day === day &&\n    selected.month === month &&\n    selected.year === year;\n\n  // Previous month days\n  const prevMonthLastDay = new Date(currentYear, currentMonth, 0).getDate();\n  const prevMonth = currentMonth === 0 ? 11 : currentMonth - 1;\n  const prevYear = currentMonth === 0 ? currentYear - 1 : currentYear;\n  for (let i = startDay - 1; i >= 0; i--) {\n    const day = prevMonthLastDay - i;\n    calendarDays.push({\n      date: day,\n      month: prevMonth,\n      year: prevYear,\n      isCurrentMonth: false,\n      isToday: false,\n      isSelected: isSelected(day, prevMonth, prevYear),\n    });\n  }\n\n  // Current month days\n  for (let day = 1; day <= lastDay.getDate(); day++) {\n    const isToday =\n      day === todayDay &&\n      currentMonth === todayMonth &&\n      currentYear === todayYear;\n    calendarDays.push({\n      date: day,\n      month: currentMonth,\n      year: currentYear,\n      isCurrentMonth: true,\n      isToday,\n      isSelected: isSelected(day, currentMonth, currentYear),\n    });\n  }\n\n  // Next month days to fill the grid (6 rows x 7 days = 42).\n  const remainingDays = 42 - calendarDays.length;\n  const nextMonth = currentMonth === 11 ? 0 : currentMonth + 1;\n  const nextYear = currentMonth === 11 ? currentYear + 1 : currentYear;\n  for (let day = 1; day <= remainingDays; day++) {\n    calendarDays.push({\n      date: day,\n      month: nextMonth,\n      year: nextYear,\n      isCurrentMonth: false,\n      isToday: false,\n      isSelected: isSelected(day, nextMonth, nextYear),\n    });\n  }\n\n  return calendarDays;\n}\n"]}

package/esm2022/lib/directives/typed-template.directive.mjs

@@ -0,0 +1,38 @@
+/* eslint-disable @angular-eslint/directive-selector */
+import { Directive, input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive that provides typed context for an `ng-template`.
+ *
+ * This is a compile-time helper: it does not affect runtime behavior,
+ * but it allows Angular's template type checker to infer the template context.
+ *
+ * Usage:
+ * ```html
+ * <ng-template #tpl let-data [typedContext]="someContext">...</ng-template>
+ * ```
+ */
+export class TypedTemplateDirective {
+    /**
+     * Typed context value used only for type inference.
+     * This input is not read at runtime.
+     */
+    typedContext = input.required();
+    /**
+     * Template context guard to inform Angular's template type system.
+     * Always returns `true` at runtime; used purely for typing.
+     */
+    static ngTemplateContextGuard(dir, ctx) {
+        return true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TypedTemplateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.17", type: TypedTemplateDirective, isStandalone: true, selector: "ng-template[typedContext]", inputs: { typedContext: { classPropertyName: "typedContext", publicName: "typedContext", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TypedTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ng-template[typedContext]',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/env/angular/provide-runtime-config.mjs

@@ -1,5 +1,6 @@
 import { inject, Injectable, InjectionToken, makeEnvironmentProviders, provideAppInitializer, } from '@angular/core';
-import { catchError, defer, firstValueFrom, from, map, of, switchMap, tap, } from 'rxjs';
+import { catchError, defer, firstValueFrom, from, map, of, switchMap, tap, throwError, } from 'rxjs';
+import { fromFetch } from 'rxjs/fetch';
 import { parseEnvFile } from '../core/parse-env-file';
 import * as i0 from "@angular/core";
 /**
@@ -62,13 +63,14 @@ export function provideRuntimeConfig(kit, staticEnv, { envPath = '/env/runtime.e
          * Returns an `Observable<ConfigShape>` and caches the final result.
          */
         load() {
-            return defer(() => from(fetch(envPath).then((res) => {
+            return defer(() => fromFetch(envPath).pipe(switchMap((res) => {
                 // Handle HTTP errors explicitly so they go through catchError
                 if (!res.ok) {
-                    throw new Error(`Failed to load runtime config: ${res.status} ${res.statusText}`);
+                    return throwError(() => new Error(`Failed to load runtime config: ${res.status} ${res.statusText}`));
                 }
+                // Response.text() returns a Promise, which switchMap can handle
                 return res.text();
-            })).pipe(
+            }), 
             // 1. SPA fallback guard (server returned HTML instead of .env)
             map((raw) => {
                 const trimmed = raw.trim();
@@ -158,4 +160,4 @@ export function provideRuntimeConfig(kit, staticEnv, { envPath = '/env/runtime.e
         },
     ]);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provide-runtime-config.js","sourceRoot":"","sources":["../../../../../../../libs/tegel-angular-extensions/src/lib/env/angular/provide-runtime-config.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  EnvironmentProviders,\n  inject,\n  Injectable,\n  InjectionToken,\n  makeEnvironmentProviders,\n  provideAppInitializer,\n} from '@angular/core';\nimport {\n  catchError,\n  defer,\n  firstValueFrom,\n  from,\n  map,\n  Observable,\n  of,\n  switchMap,\n  tap,\n} from 'rxjs';\nimport z from 'zod';\nimport { EnvKit, SchemaOutput, StaticEnvFrom } from '../core/env-types';\nimport { parseEnvFile } from '../core/parse-env-file';\n\n/**\n * Builds styled console arguments for RuntimeConfig logs.\n *\n * The returned tuple can be spread directly into `console.log`,\n * allowing the browser to render a colored `[RuntimeConfig]` prefix\n * while preserving the original caller location in DevTools.\n *\n * Example:\n * ```ts\n * console.log(...rcArgs('Runtime overrides loaded.'));\n * ```\n *\n * @param msg - The message text to append after the colored prefix.\n * @returns A tuple of arguments (`[format, style, reset]`) for `console.log`.\n */\nconst rcArgs = (msg: string): Parameters<typeof console.log> => [\n  '%c[RuntimeConfig]%c ' + msg,\n  'color:#0cf;',\n  '',\n];\n\n/**\n * Options for configuring the Angular runtime-config provider.\n *\n * @property envPath\n * The URL (or path) to the runtime `.env` file that will be fetched at app start.\n * Defaults to `\"/env/runtime.env\"`.\n *\n * @property debug\n * Enables verbose console logging when `true`. Defaults to `false`.\n *\n * @property stopOnError\n * If `true`, any failure while loading/parsing/validating the runtime config\n * will reject the app initializer and **abort boot** (recommended for prod).\n * If `false`, the provider falls back to the static environment only.\n * Defaults to `true`.\n *\n * @property token\n * Optional `InjectionToken` used to expose the validated configuration\n * via Angular dependency injection. If omitted, the provider will create one\n * automatically named `ENV_CONFIG`.\n */\ninterface ProvideRuntimeConfigOptions<S extends z.ZodObject<z.ZodRawShape>> {\n  /** Path to the runtime env file (default: /env/runtime.env) */\n  envPath?: string;\n  /** Log debug info to console */\n  debug?: boolean;\n  /** Throw on error to stop app boot (default: true) */\n  stopOnError?: boolean;\n  /** Injection token used to provide the validated config via Angular DI */\n  token?: InjectionToken<SchemaOutput<S>>;\n}\n\n/**\n * Registers providers that:\n * - Fetch a runtime `.env` file at startup,\n * - Parse it to a deep-partial structure via the kit,\n * - Enforce runtime-required keys when appropriate,\n * - Merge with the static environment,\n * - Validate the **final** configuration against the Zod schema,\n * - Expose the resulting config via a generated `InjectionToken`.\n *\n * @typeParam S - Zod schema type describing the full config shape.\n * @typeParam K - List of runtime-required top-level keys.\n *\n * @param kit\n * The `EnvKit` created by `createEnvKit(schema, runtimeRequiredKeys)`.\n *\n * @param options\n * Runtime loading behavior and DI token description. See {@link ProvideRuntimeConfigOptions}.\n *\n * @returns The `EnvironmentProviders` to be added to `appConfig.providers`,\n *\n * @remarks\n * - This uses an Angular **functional app initializer** to perform the load step.\n * - If the server returns an HTML SPA fallback (instead of the `.env` file), the provider\n *   quietly uses the static environment (no runtime overrides).\n */\nexport function provideRuntimeConfig<\n  S extends z.ZodObject<z.ZodRawShape>,\n  K extends readonly (keyof z.output<S>)[]\n>(\n  kit: EnvKit<S, K>,\n  staticEnv: StaticEnvFrom<S, K>,\n  {\n    envPath = '/env/runtime.env',\n    debug = false,\n    stopOnError = true,\n    token,\n  }: ProvideRuntimeConfigOptions<S> = {}\n): EnvironmentProviders {\n  // The validated config type derived from the schema.\n  type EnvConfig = SchemaOutput<S>;\n\n  // Typed token used to expose the final validated config via DI.\n  const configToken = token ?? new InjectionToken<EnvConfig>('ENV_CONFIG');\n\n  /**\n   * Angular service that handles fetching, parsing, validating, and caching\n   * of the runtime environment configuration.\n   */\n  @Injectable({ providedIn: 'root' })\n  class RuntimeConfigService {\n    // Cached instance of the validated configuration.\n    private config?: EnvConfig;\n\n    /**\n     * Loads, parses, merges and validates the runtime configuration.\n     * Returns an `Observable<ConfigShape>` and caches the final result.\n     */\n    load(): Observable<EnvConfig> {\n      return defer(() =>\n        from(\n          fetch(envPath).then((res) => {\n            // Handle HTTP errors explicitly so they go through catchError\n            if (!res.ok) {\n              throw new Error(\n                `Failed to load runtime config: ${res.status} ${res.statusText}`\n              );\n            }\n            return res.text();\n          })\n        ).pipe(\n          // 1. SPA fallback guard (server returned HTML instead of .env)\n          map((raw: string): string | null => {\n            const trimmed = raw.trim();\n            const looksHtml =\n              /^\\s*<!doctype/i.test(trimmed) || /^\\s*<html[\\s>]/i.test(trimmed);\n            if (looksHtml) {\n              if (debug) {\n                console.log(\n                  ...rcArgs(\n                    'No runtime environment file detected, using static environment only.'\n                  )\n                );\n              }\n              // Signal “no runtime.env, use static only”\n              return null;\n            }\n            return raw;\n          }),\n          tap((v: string | null) => {\n            if (!debug) return;\n            console.log(\n              ...rcArgs(\n                v === null\n                  ? 'No runtime environment file defined, using static environment'\n                  : 'Runtime environment file loaded, applying overrides.'\n              )\n            );\n          }),\n          // 2. Either continue the pipe or return defaults\n          switchMap((raw: string | null): Observable<EnvConfig> => {\n            if (raw === null) {\n              return from(kit.mergeAndValidateAsync(staticEnv)).pipe(\n                tap((cfg) => (this.config = cfg))\n              );\n            }\n\n            // 3. Parse raw `.env` text -> object, then deep-partial-parse via kit\n            const runtimeConfigRaw: Record<string, unknown> = parseEnvFile(raw);\n            return from(kit.parseRuntimeOverridesAsync(runtimeConfigRaw)).pipe(\n              tap((overrides: Partial<EnvConfig>) => {\n                if (debug)\n                  console.log(...rcArgs('Runtime config (parsed):'), overrides);\n              }),\n              // 4. Merge static + overrides and validate the final config (async)\n              switchMap(\n                (overrides: Partial<EnvConfig>): Observable<EnvConfig> =>\n                  from(kit.mergeAndValidateAsync(staticEnv, overrides))\n              ),\n\n              // 5. Cache the validated config for synchronous access later\n              tap((mergedConfig: EnvConfig) => {\n                if (debug)\n                  console.log(...rcArgs('Merged config:'), mergedConfig);\n                this.config = mergedConfig;\n              })\n            );\n          }),\n\n          // 6. Error handling: fail fast or gracefully fall back to static-only\n          catchError((err: unknown) => {\n            if (stopOnError) {\n              // Reject app initialization (recommended for production)\n              throw err;\n            }\n            console.error(\n              ...rcArgs('Error occurred while loading runtime config:'),\n              err\n            );\n\n            return of(this.useDefaults());\n          })\n        )\n      );\n    }\n\n    /**\n     * Returns the current configuration.\n     * If not yet loaded, returns a validated static-only configuration.\n     */\n    get(): EnvConfig {\n      if (!this.config) {\n        throw new Error(\n          'RuntimeConfigService.get() called before configuration was loaded. ' +\n            'Ensure provideAppInitializer waits for RuntimeConfigService.load().'\n        );\n      }\n\n      return this.config;\n    }\n\n    /**\n     * Sets the current configuration to a validated static-only configuration\n     * Used when the runtime `.env` file is missing.\n     */\n    private useDefaults(): EnvConfig {\n      // Note: this uses the static env; merge+validate is performed in `get()` if needed.\n      this.config ??= staticEnv as EnvConfig;\n      return this.config;\n    }\n  }\n\n  // Register the service + initializer + token exposure with Angular DI.\n  return makeEnvironmentProviders([\n    RuntimeConfigService,\n\n    // Angular 19+ functional initializer (subscribes to the load Observable)\n    // Using firstValueFrom to enforece \"await until loaded\" semantics\n    provideAppInitializer(() =>\n      firstValueFrom(inject(RuntimeConfigService).load())\n    ),\n\n    // Expose the final validated config via the generated token\n    {\n      provide: configToken,\n      useFactory: () => inject(RuntimeConfigService).get(),\n    },\n  ]);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provide-runtime-config.js","sourceRoot":"","sources":["../../../../../../../libs/tegel-angular-extensions/src/lib/env/angular/provide-runtime-config.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  EnvironmentProviders,\n  inject,\n  Injectable,\n  InjectionToken,\n  makeEnvironmentProviders,\n  provideAppInitializer,\n} from '@angular/core';\nimport {\n  catchError,\n  defer,\n  firstValueFrom,\n  from,\n  map,\n  Observable,\n  of,\n  switchMap,\n  tap,\n  throwError,\n} from 'rxjs';\nimport { fromFetch } from 'rxjs/fetch';\nimport z from 'zod';\nimport { EnvKit, SchemaOutput, StaticEnvFrom } from '../core/env-types';\nimport { parseEnvFile } from '../core/parse-env-file';\n\n/**\n * Builds styled console arguments for RuntimeConfig logs.\n *\n * The returned tuple can be spread directly into `console.log`,\n * allowing the browser to render a colored `[RuntimeConfig]` prefix\n * while preserving the original caller location in DevTools.\n *\n * Example:\n * ```ts\n * console.log(...rcArgs('Runtime overrides loaded.'));\n * ```\n *\n * @param msg - The message text to append after the colored prefix.\n * @returns A tuple of arguments (`[format, style, reset]`) for `console.log`.\n */\nconst rcArgs = (msg: string): Parameters<typeof console.log> => [\n  '%c[RuntimeConfig]%c ' + msg,\n  'color:#0cf;',\n  '',\n];\n\n/**\n * Options for configuring the Angular runtime-config provider.\n *\n * @property envPath\n * The URL (or path) to the runtime `.env` file that will be fetched at app start.\n * Defaults to `\"/env/runtime.env\"`.\n *\n * @property debug\n * Enables verbose console logging when `true`. Defaults to `false`.\n *\n * @property stopOnError\n * If `true`, any failure while loading/parsing/validating the runtime config\n * will reject the app initializer and **abort boot** (recommended for prod).\n * If `false`, the provider falls back to the static environment only.\n * Defaults to `true`.\n *\n * @property token\n * Optional `InjectionToken` used to expose the validated configuration\n * via Angular dependency injection. If omitted, the provider will create one\n * automatically named `ENV_CONFIG`.\n */\ninterface ProvideRuntimeConfigOptions<S extends z.ZodObject<z.ZodRawShape>> {\n  /** Path to the runtime env file (default: /env/runtime.env) */\n  envPath?: string;\n  /** Log debug info to console */\n  debug?: boolean;\n  /** Throw on error to stop app boot (default: true) */\n  stopOnError?: boolean;\n  /** Injection token used to provide the validated config via Angular DI */\n  token?: InjectionToken<SchemaOutput<S>>;\n}\n\n/**\n * Registers providers that:\n * - Fetch a runtime `.env` file at startup,\n * - Parse it to a deep-partial structure via the kit,\n * - Enforce runtime-required keys when appropriate,\n * - Merge with the static environment,\n * - Validate the **final** configuration against the Zod schema,\n * - Expose the resulting config via a generated `InjectionToken`.\n *\n * @typeParam S - Zod schema type describing the full config shape.\n * @typeParam K - List of runtime-required top-level keys.\n *\n * @param kit\n * The `EnvKit` created by `createEnvKit(schema, runtimeRequiredKeys)`.\n *\n * @param options\n * Runtime loading behavior and DI token description. See {@link ProvideRuntimeConfigOptions}.\n *\n * @returns The `EnvironmentProviders` to be added to `appConfig.providers`,\n *\n * @remarks\n * - This uses an Angular **functional app initializer** to perform the load step.\n * - If the server returns an HTML SPA fallback (instead of the `.env` file), the provider\n *   quietly uses the static environment (no runtime overrides).\n */\nexport function provideRuntimeConfig<\n  S extends z.ZodObject<z.ZodRawShape>,\n  K extends readonly (keyof z.output<S>)[],\n>(\n  kit: EnvKit<S, K>,\n  staticEnv: StaticEnvFrom<S, K>,\n  {\n    envPath = '/env/runtime.env',\n    debug = false,\n    stopOnError = true,\n    token,\n  }: ProvideRuntimeConfigOptions<S> = {},\n): EnvironmentProviders {\n  // The validated config type derived from the schema.\n  type EnvConfig = SchemaOutput<S>;\n\n  // Typed token used to expose the final validated config via DI.\n  const configToken = token ?? new InjectionToken<EnvConfig>('ENV_CONFIG');\n\n  /**\n   * Angular service that handles fetching, parsing, validating, and caching\n   * of the runtime environment configuration.\n   */\n  @Injectable({ providedIn: 'root' })\n  class RuntimeConfigService {\n    // Cached instance of the validated configuration.\n    private config?: EnvConfig;\n\n    /**\n     * Loads, parses, merges and validates the runtime configuration.\n     * Returns an `Observable<ConfigShape>` and caches the final result.\n     */\n    load(): Observable<EnvConfig> {\n      return defer(() =>\n        fromFetch(envPath).pipe(\n          switchMap((res) => {\n            // Handle HTTP errors explicitly so they go through catchError\n            if (!res.ok) {\n              return throwError(\n                () =>\n                  new Error(\n                    `Failed to load runtime config: ${res.status} ${res.statusText}`,\n                  ),\n              );\n            }\n\n            // Response.text() returns a Promise, which switchMap can handle\n            return res.text();\n          }),\n          // 1. SPA fallback guard (server returned HTML instead of .env)\n          map((raw: string): string | null => {\n            const trimmed = raw.trim();\n            const looksHtml =\n              /^\\s*<!doctype/i.test(trimmed) || /^\\s*<html[\\s>]/i.test(trimmed);\n            if (looksHtml) {\n              if (debug) {\n                console.log(\n                  ...rcArgs(\n                    'No runtime environment file detected, using static environment only.',\n                  ),\n                );\n              }\n              // Signal “no runtime.env, use static only”\n              return null;\n            }\n            return raw;\n          }),\n          tap((v: string | null) => {\n            if (!debug) return;\n            console.log(\n              ...rcArgs(\n                v === null\n                  ? 'No runtime environment file defined, using static environment'\n                  : 'Runtime environment file loaded, applying overrides.',\n              ),\n            );\n          }),\n          // 2. Either continue the pipe or return defaults\n          switchMap((raw: string | null): Observable<EnvConfig> => {\n            if (raw === null) {\n              return from(kit.mergeAndValidateAsync(staticEnv)).pipe(\n                tap((cfg) => (this.config = cfg)),\n              );\n            }\n\n            // 3. Parse raw `.env` text -> object, then deep-partial-parse via kit\n            const runtimeConfigRaw: Record<string, unknown> = parseEnvFile(raw);\n            return from(kit.parseRuntimeOverridesAsync(runtimeConfigRaw)).pipe(\n              tap((overrides: Partial<EnvConfig>) => {\n                if (debug)\n                  console.log(...rcArgs('Runtime config (parsed):'), overrides);\n              }),\n              // 4. Merge static + overrides and validate the final config (async)\n              switchMap(\n                (overrides: Partial<EnvConfig>): Observable<EnvConfig> =>\n                  from(kit.mergeAndValidateAsync(staticEnv, overrides)),\n              ),\n\n              // 5. Cache the validated config for synchronous access later\n              tap((mergedConfig: EnvConfig) => {\n                if (debug)\n                  console.log(...rcArgs('Merged config:'), mergedConfig);\n                this.config = mergedConfig;\n              }),\n            );\n          }),\n\n          // 6. Error handling: fail fast or gracefully fall back to static-only\n          catchError((err: unknown) => {\n            if (stopOnError) {\n              // Reject app initialization (recommended for production)\n              throw err;\n            }\n            console.error(\n              ...rcArgs('Error occurred while loading runtime config:'),\n              err,\n            );\n\n            return of(this.useDefaults());\n          }),\n        ),\n      );\n    }\n\n    /**\n     * Returns the current configuration.\n     * If not yet loaded, returns a validated static-only configuration.\n     */\n    get(): EnvConfig {\n      if (!this.config) {\n        throw new Error(\n          'RuntimeConfigService.get() called before configuration was loaded. ' +\n            'Ensure provideAppInitializer waits for RuntimeConfigService.load().',\n        );\n      }\n\n      return this.config;\n    }\n\n    /**\n     * Sets the current configuration to a validated static-only configuration\n     * Used when the runtime `.env` file is missing.\n     */\n    private useDefaults(): EnvConfig {\n      // Note: this uses the static env; merge+validate is performed in `get()` if needed.\n      this.config ??= staticEnv as EnvConfig;\n      return this.config;\n    }\n  }\n\n  // Register the service + initializer + token exposure with Angular DI.\n  return makeEnvironmentProviders([\n    RuntimeConfigService,\n\n    // Angular 19+ functional initializer (subscribes to the load Observable)\n    // Using firstValueFrom to enforece \"await until loaded\" semantics\n    provideAppInitializer(() =>\n      firstValueFrom(inject(RuntimeConfigService).load()),\n    ),\n\n    // Expose the final validated config via the generated token\n    {\n      provide: configToken,\n      useFactory: () => inject(RuntimeConfigService).get(),\n    },\n  ]);\n}\n"]}

package/esm2022/lib/modal/components/modal/modal.component.mjs

@@ -0,0 +1,128 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ElementRef, TemplateRef, computed, effect, input, output, viewChild, } from '@angular/core';
+import { TdsModal, TegelModule } from '@scania/tegel-angular-17';
+import { DynamicComponentDirective } from '../../directives/dynamic-component.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@scania/tegel-angular-17";
+/**
+ * Renders a single modal instance backed by the Tegel <tds-modal> web component.
+ *
+ * Responsibilities:
+ * - Initialize the underlying web component once it is ready.
+ * - Apply the desired open/close state based on `modal.isOpen`.
+ * - Render header/body/action content (including dynamic components).
+ */
+export class ModalComponent {
+    /**
+     * Modal configuration and runtime state.
+     */
+    modal = input.required();
+    /**
+     * Emits the modal id when the modal is closed by the user.
+     */
+    closed = output();
+    // Reference to the underlying web component instance.
+    _modalRef = viewChild(TdsModal, {
+        read: (ElementRef),
+    });
+    /**
+     * Resolved DOM element for the underlying <tds-modal>.
+     */
+    modalEl = computed(() => this._modalRef()?.nativeElement ?? null);
+    /** Tracks whether the modal has been initialized. */
+    initialized = false;
+    constructor() {
+        effect(() => {
+            // Track input changes and sync desired open state to the web component.
+            this.modal();
+            void this.applyOpenState();
+        });
+    }
+    /**
+     * Type guard for TemplateRef values.
+     * @param value Value to test.
+     */
+    isTemplateRef(value) {
+        return value instanceof TemplateRef;
+    }
+    /**
+     * Type guard for component-backed modal bodies.
+     * @param body Body value to test.
+     */
+    isComponentBody(body) {
+        return typeof body === 'object' && body !== null && 'component' in body;
+    }
+    /**
+     * Type guard for template-backed modal bodies.
+     * @param body Body value to test.
+     */
+    isTemplateBody(body) {
+        return typeof body === 'object' && body !== null && 'template' in body;
+    }
+    /**
+     * Invokes an action button handler (sync or async).
+     * @param button Modal button descriptor.
+     */
+    async handleButtonClick(button) {
+        try {
+            await button.onClick?.();
+        }
+        catch (err) {
+            console.error('[tae-modal] Button onClick failed:', err);
+        }
+    }
+    /**
+     * Initializes the underlying <tds-modal> after view init.
+     */
+    ngAfterViewInit() {
+        void this.initializeModal();
+    }
+    /**
+     * Calls the web component's initializeModal() once.
+     */
+    async initializeModal() {
+        const el = this.modalEl();
+        if (!el) {
+            console.warn('[tae-modal] Modal element not found; cannot initialize.');
+            return;
+        }
+        if (this.initialized)
+            return;
+        const ready = await el.componentOnReady();
+        if (!ready) {
+            console.warn('[tae-modal] Modal element not ready; initialization skipped.');
+            return;
+        }
+        await el.initializeModal();
+        this.initialized = true;
+    }
+    /**
+     * Applies the desired open/close state to the web component.
+     */
+    async applyOpenState() {
+        const modal = this.modal();
+        const el = this.modalEl();
+        if (!el)
+            return;
+        if (!this.initialized) {
+            // Initialize once before issuing show/close calls.
+            await this.initializeModal();
+            if (!this.initialized)
+                return;
+        }
+        if (modal.isOpen) {
+            await el.showModal();
+        }
+        else {
+            await el.closeModal();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: ModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.17", type: ModalComponent, isStandalone: true, selector: "tae-modal", inputs: { modal: { classPropertyName: "modal", publicName: "modal", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { closed: "closed" }, viewQueries: [{ propertyName: "_modalRef", first: true, predicate: TdsModal, descendants: true, read: ElementRef, isSignal: true }], ngImport: i0, template: "@let modalObj = modal();\n\n<tds-modal\n  [id]=\"modalObj.id\"\n  [selector]=\"modalObj.selector\"\n  [referenceEl]=\"modalObj.referenceEl\"\n  [size]=\"modalObj.size\"\n  [actionsPosition]=\"modalObj.actionsPosition\"\n  [prevent]=\"modalObj.prevent\"\n  [closable]=\"modalObj.closable\"\n  [tdsAlertDialog]=\"modalObj.alertDialog\"\n  (tdsClose)=\"this.closed.emit(modalObj.id)\"\n>\n  @let header = modalObj.header;\n  @if (header) {\n    @if (isTemplateRef(header)) {\n      <span slot=\"header\">\n        <ng-container [ngTemplateOutlet]=\"header\" />\n      </span>\n    } @else {\n      <span slot=\"header\">{{ header }}</span>\n    }\n  }\n\n  @if (!modalObj.lazy || modalObj.isOpen) {\n    @let body = modalObj.body;\n    @if (body) {\n      <span slot=\"body\">\n        @if (isComponentBody(body)) {\n          <ng-container\n            taeDynamicComponent\n            [component]=\"body.component\"\n            [inputs]=\"body.inputs\"\n            [outputs]=\"body.outputs\"\n          />\n        } @else if (isTemplateBody(body)) {\n          <ng-container\n            [ngTemplateOutlet]=\"body.template\"\n            [ngTemplateOutletContext]=\"{ $implicit: body.context }\"\n          />\n        } @else {\n          {{ body }}\n        }\n      </span>\n    }\n  }\n\n  @let buttons = modalObj.buttons;\n  @if (buttons?.length) {\n    <span slot=\"actions\" class=\"tds-u-flex tds-u-gap2\">\n      @for (button of buttons; track $index) {\n        <tds-button\n          [text]=\"button.text\"\n          [variant]=\"button.variant ?? 'primary'\"\n          [size]=\"button.size ?? 'md'\"\n          [disabled]=\"button.disabled ?? false\"\n          [attr.data-dismiss-modal]=\"button.dismiss ? '' : null\"\n          (click)=\"handleButtonClick(button)\"\n        ></tds-button>\n      }\n    </span>\n  }\n</tds-modal>\n", styles: [":host{display:contents}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: TegelModule }, { kind: "component", type: i2.TdsButton, selector: "tds-button", inputs: ["animation", "disabled", "fullbleed", "modeVariant", "name", "size", "tdsAriaLabel", "text", "type", "value", "variant"] }, { kind: "component", type: i2.TdsModal, selector: "tds-modal", inputs: ["actionsPosition", "closable", "header", "prevent", "referenceEl", "selector", "show", "size", "tdsAlertDialog"] }, { kind: "directive", type: DynamicComponentDirective, selector: "[taeDynamicComponent]", inputs: ["component", "inputs", "outputs"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: ModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tae-modal', imports: [CommonModule, TegelModule, DynamicComponentDirective], changeDetection: ChangeDetectionStrategy.OnPush, template: "@let modalObj = modal();\n\n<tds-modal\n  [id]=\"modalObj.id\"\n  [selector]=\"modalObj.selector\"\n  [referenceEl]=\"modalObj.referenceEl\"\n  [size]=\"modalObj.size\"\n  [actionsPosition]=\"modalObj.actionsPosition\"\n  [prevent]=\"modalObj.prevent\"\n  [closable]=\"modalObj.closable\"\n  [tdsAlertDialog]=\"modalObj.alertDialog\"\n  (tdsClose)=\"this.closed.emit(modalObj.id)\"\n>\n  @let header = modalObj.header;\n  @if (header) {\n    @if (isTemplateRef(header)) {\n      <span slot=\"header\">\n        <ng-container [ngTemplateOutlet]=\"header\" />\n      </span>\n    } @else {\n      <span slot=\"header\">{{ header }}</span>\n    }\n  }\n\n  @if (!modalObj.lazy || modalObj.isOpen) {\n    @let body = modalObj.body;\n    @if (body) {\n      <span slot=\"body\">\n        @if (isComponentBody(body)) {\n          <ng-container\n            taeDynamicComponent\n            [component]=\"body.component\"\n            [inputs]=\"body.inputs\"\n            [outputs]=\"body.outputs\"\n          />\n        } @else if (isTemplateBody(body)) {\n          <ng-container\n            [ngTemplateOutlet]=\"body.template\"\n            [ngTemplateOutletContext]=\"{ $implicit: body.context }\"\n          />\n        } @else {\n          {{ body }}\n        }\n      </span>\n    }\n  }\n\n  @let buttons = modalObj.buttons;\n  @if (buttons?.length) {\n    <span slot=\"actions\" class=\"tds-u-flex tds-u-gap2\">\n      @for (button of buttons; track $index) {\n        <tds-button\n          [text]=\"button.text\"\n          [variant]=\"button.variant ?? 'primary'\"\n          [size]=\"button.size ?? 'md'\"\n          [disabled]=\"button.disabled ?? false\"\n          [attr.data-dismiss-modal]=\"button.dismiss ? '' : null\"\n          (click)=\"handleButtonClick(button)\"\n        ></tds-button>\n      }\n    </span>\n  }\n</tds-modal>\n", styles: [":host{display:contents}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.component.js","sourceRoot":"","sources":["../../../../../../../../libs/tegel-angular-extensions/src/lib/modal/components/modal/modal.component.ts","../../../../../../../../libs/tegel-angular-extensions/src/lib/modal/components/modal/modal.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  TemplateRef,\n  computed,\n  effect,\n  input,\n  output,\n  viewChild,\n} from '@angular/core';\nimport { TdsModal, TegelModule } from '@scania/tegel-angular-17';\nimport { DynamicComponentDirective } from '../../directives/dynamic-component.directive';\nimport {\n  Modal,\n  ModalBody,\n  ModalComponentBody,\n  ModalTemplateBody,\n} from '../../schema/modal.model';\nimport { ModalButton } from '../../schema/modal.types';\n\n/**\n * Renders a single modal instance backed by the Tegel <tds-modal> web component.\n *\n * Responsibilities:\n * - Initialize the underlying web component once it is ready.\n * - Apply the desired open/close state based on `modal.isOpen`.\n * - Render header/body/action content (including dynamic components).\n */\n@Component({\n  selector: 'tae-modal',\n  templateUrl: './modal.component.html',\n  styleUrls: ['./modal.component.scss'],\n  imports: [CommonModule, TegelModule, DynamicComponentDirective],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ModalComponent implements AfterViewInit {\n  /**\n   * Modal configuration and runtime state.\n   */\n  readonly modal = input.required<Modal>();\n  /**\n   * Emits the modal id when the modal is closed by the user.\n   */\n  protected readonly closed = output<string>();\n  // Reference to the underlying web component instance.\n  private readonly _modalRef = viewChild(TdsModal, {\n    read: ElementRef<HTMLTdsModalElement>,\n  });\n\n  /**\n   * Resolved DOM element for the underlying <tds-modal>.\n   */\n  protected readonly modalEl = computed(\n    () => this._modalRef()?.nativeElement ?? null,\n  );\n\n  /** Tracks whether the modal has been initialized. */\n  private initialized = false;\n\n  constructor() {\n    effect(() => {\n      // Track input changes and sync desired open state to the web component.\n      this.modal();\n      void this.applyOpenState();\n    });\n  }\n\n  /**\n   * Type guard for TemplateRef values.\n   * @param value Value to test.\n   */\n  protected isTemplateRef(value: unknown): value is TemplateRef<unknown> {\n    return value instanceof TemplateRef;\n  }\n\n  /**\n   * Type guard for component-backed modal bodies.\n   * @param body Body value to test.\n   */\n  protected isComponentBody(\n    body: ModalBody<unknown>,\n  ): body is ModalComponentBody<unknown> {\n    return typeof body === 'object' && body !== null && 'component' in body;\n  }\n\n  /**\n   * Type guard for template-backed modal bodies.\n   * @param body Body value to test.\n   */\n  protected isTemplateBody(\n    body: ModalBody<unknown>,\n  ): body is ModalTemplateBody {\n    return typeof body === 'object' && body !== null && 'template' in body;\n  }\n\n  /**\n   * Invokes an action button handler (sync or async).\n   * @param button Modal button descriptor.\n   */\n  async handleButtonClick(button: ModalButton): Promise<void> {\n    try {\n      await button.onClick?.();\n    } catch (err) {\n      console.error('[tae-modal] Button onClick failed:', err);\n    }\n  }\n\n  /**\n   * Initializes the underlying <tds-modal> after view init.\n   */\n  ngAfterViewInit(): void {\n    void this.initializeModal();\n  }\n\n  /**\n   * Calls the web component's initializeModal() once.\n   */\n  private async initializeModal(): Promise<void> {\n    const el = this.modalEl();\n    if (!el) {\n      console.warn('[tae-modal] Modal element not found; cannot initialize.');\n      return;\n    }\n    if (this.initialized) return;\n\n    const ready = await el.componentOnReady();\n    if (!ready) {\n      console.warn(\n        '[tae-modal] Modal element not ready; initialization skipped.',\n      );\n      return;\n    }\n\n    await el.initializeModal();\n    this.initialized = true;\n  }\n\n  /**\n   * Applies the desired open/close state to the web component.\n   */\n  private async applyOpenState(): Promise<void> {\n    const modal = this.modal();\n    const el = this.modalEl();\n    if (!el) return;\n    if (!this.initialized) {\n      // Initialize once before issuing show/close calls.\n      await this.initializeModal();\n      if (!this.initialized) return;\n    }\n    if (modal.isOpen) {\n      await el.showModal();\n    } else {\n      await el.closeModal();\n    }\n  }\n}\n","@let modalObj = modal();\n\n<tds-modal\n  [id]=\"modalObj.id\"\n  [selector]=\"modalObj.selector\"\n  [referenceEl]=\"modalObj.referenceEl\"\n  [size]=\"modalObj.size\"\n  [actionsPosition]=\"modalObj.actionsPosition\"\n  [prevent]=\"modalObj.prevent\"\n  [closable]=\"modalObj.closable\"\n  [tdsAlertDialog]=\"modalObj.alertDialog\"\n  (tdsClose)=\"this.closed.emit(modalObj.id)\"\n>\n  @let header = modalObj.header;\n  @if (header) {\n    @if (isTemplateRef(header)) {\n      <span slot=\"header\">\n        <ng-container [ngTemplateOutlet]=\"header\" />\n      </span>\n    } @else {\n      <span slot=\"header\">{{ header }}</span>\n    }\n  }\n\n  @if (!modalObj.lazy || modalObj.isOpen) {\n    @let body = modalObj.body;\n    @if (body) {\n      <span slot=\"body\">\n        @if (isComponentBody(body)) {\n          <ng-container\n            taeDynamicComponent\n            [component]=\"body.component\"\n            [inputs]=\"body.inputs\"\n            [outputs]=\"body.outputs\"\n          />\n        } @else if (isTemplateBody(body)) {\n          <ng-container\n            [ngTemplateOutlet]=\"body.template\"\n            [ngTemplateOutletContext]=\"{ $implicit: body.context }\"\n          />\n        } @else {\n          {{ body }}\n        }\n      </span>\n    }\n  }\n\n  @let buttons = modalObj.buttons;\n  @if (buttons?.length) {\n    <span slot=\"actions\" class=\"tds-u-flex tds-u-gap2\">\n      @for (button of buttons; track $index) {\n        <tds-button\n          [text]=\"button.text\"\n          [variant]=\"button.variant ?? 'primary'\"\n          [size]=\"button.size ?? 'md'\"\n          [disabled]=\"button.disabled ?? false\"\n          [attr.data-dismiss-modal]=\"button.dismiss ? '' : null\"\n          (click)=\"handleButtonClick(button)\"\n        ></tds-button>\n      }\n    </span>\n  }\n</tds-modal>\n"]}

package/esm2022/lib/modal/components/modal-host/modal-host.component.mjs

@@ -0,0 +1,32 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
+import { ModalService } from '../../modal.service';
+import { ModalComponent } from '../modal/modal.component';
+import * as i0 from "@angular/core";
+/**
+ * Hosts and renders all active modals.
+ *
+ * The host listens for close events from each modal instance and
+ * forwards them to the modal service, which owns modal lifecycle.
+ */
+export class ModalHostComponent {
+    modalService = inject(ModalService);
+    /**
+     * Map of active modals keyed by id.
+     */
+    modalsSignal = this.modalService.modals;
+    /**
+     * Handles close events from child modal components.
+     * @param id Modal id that emitted the close event.
+     */
+    handleClosed(id) {
+        this.modalService.close(id);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: ModalHostComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.17", type: ModalHostComponent, isStandalone: true, selector: "tae-modal-host", ngImport: i0, template: "@for (modal of modalsSignal().values(); track modal.id) {\n  <tae-modal [modal]=\"modal\" (closed)=\"handleClosed($event)\" />\n}\n", styles: [":host{display:contents}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: ModalComponent, selector: "tae-modal", inputs: ["modal"], outputs: ["closed"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: ModalHostComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tae-modal-host', imports: [CommonModule, ModalComponent], changeDetection: ChangeDetectionStrategy.OnPush, template: "@for (modal of modalsSignal().values(); track modal.id) {\n  <tae-modal [modal]=\"modal\" (closed)=\"handleClosed($event)\" />\n}\n", styles: [":host{display:contents}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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