@scania-nl/tegel-angular-extensions 0.0.4 → 0.0.6

package/docker/nginx.conf

@@ -0,0 +1,69 @@
+worker_processes auto;
+
+pid /tmp/nginx.pid;
+
+events {
+    worker_connections 1024;
+}
+
+http {
+    include       /etc/nginx/mime.types;
+    default_type  application/octet-stream;
+
+    # Logging
+    access_log off;
+    error_log  /dev/stderr warn;
+
+    # Performance
+    sendfile        on;
+    tcp_nopush      on;
+    tcp_nodelay     on;
+    keepalive_timeout  65;
+    keepalive_requests 1000;
+
+    # Compression
+    gzip on;
+    gzip_vary on;
+    gzip_proxied any;
+    gzip_min_length 256;
+    gzip_comp_level 6;
+    gzip_types
+        text/plain
+        text/css
+        text/xml
+        text/javascript
+        application/javascript
+        application/x-javascript
+        application/json
+        application/xml
+        application/xml+rss
+        font/ttf
+        font/otf
+        image/svg+xml;
+
+    server {
+        # listen       8080;
+        server_name  localhost;
+
+        root /usr/share/nginx/html;
+        index index.html;
+
+        # Angular Routing
+        location / {
+            try_files $uri $uri/ /index.html;
+        }
+
+        # Static Assets Caching
+        location ~* \.(?:ico|css|js|gif|jpe?g|png|woff2?|eot|ttf|svg|map)$ {
+            expires 1y;
+            access_log off;
+            add_header Cache-Control "public, immutable";
+        }
+
+        # Optional: Explicit asset route
+        location /assets/ {
+            expires 1y;
+            add_header Cache-Control "public, immutable";
+        }
+    }
+}

package/esm2022/index.mjs

@@ -1,5 +1,24 @@
-export * from './lib/toast/provide-toast';
-export * from './lib/toast/toast.config';
-export * from './lib/toast/toast.service';
-export * from './lib/toast/models/toast.model';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL3RlZ2VsLWFuZ3VsYXItZXh0ZW5zaW9ucy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxnQ0FBZ0MsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL3RvYXN0L3Byb3ZpZGUtdG9hc3QnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdG9hc3QvdG9hc3QuY29uZmlnJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3RvYXN0L3RvYXN0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdG9hc3QvbW9kZWxzL3RvYXN0Lm1vZGVsJyJdfQ==
+// --------------------------------------------------
+// Toast Module Exports
+// --------------------------------------------------
+export { provideToast } from './lib/toast/provide-toast';
+export { DEFAULT_TOAST_CONFIG, TOAST_CONFIG, } from './lib/toast/toast.config';
+export { ToastService } from './lib/toast/toast.service';
+// --------------------------------------------------
+// Env Module Exports
+// --------------------------------------------------
+// Core
+export { createEnvKit } from './lib/env/core/create-env-kit';
+export { parseEnvFile } from './lib/env/core/parse-env-file';
+// Angular
+export { provideRuntimeConfig } from './lib/env/angular/provide-runtime-config';
+export { provideStaticConfig } from './lib/env/angular/provide-static-config';
+// --------------------------------------------------
+// Directive Module Exports
+// --------------------------------------------------
+export { HardRefreshDirective } from './lib/directives/hard-refresh.directive';
+// --------------------------------------------------
+// Component Module Exports
+// --------------------------------------------------
+export { TaeFooterComponent } from './lib/components/tae-footer/tae-footer.component';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/tae-footer/tae-footer.component.mjs

@@ -0,0 +1,48 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * An enhanced standalone footer component based on the Tegel `TdsFooterComponent`.
+ *
+ * `TaeFooterComponent` maintains the same visual style as the original
+ * Tegel footer, but adds two key improvements:
+ *
+ * - A **compact “small” variant** for layouts where vertical space is limited.
+ * - Optional **version display**, allowing applications to show their
+ *   build or release version directly in the footer.
+ *
+ * Example:
+ * ```html
+ * <tae-footer variant="small" version="v1.0.0" />
+ * ```
+ */
+export class TaeFooterComponent {
+    /**
+     * Determines the visual layout of the footer.
+     *
+     * - `"normal"` displays the standard footer layout (aligned to tds-footer)
+     * - `"small"` produces a more compact version suitable for tight layouts
+     *
+     * @default 'normal'
+     */
+    variant = input('normal');
+    /**
+     * Optional application version string to display in the footer.
+     *
+     * When provided, it appears left of the Scania logo.
+     * If omitted or `undefined`, the version section is not shown.
+     */
+    version = input();
+    /**
+     * The current year used in the copyright section.
+     */
+    currentYear = new Date().getFullYear();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TaeFooterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.17", type: TaeFooterComponent, isStandalone: true, selector: "tae-footer", inputs: { variant: { classPropertyName: "variant", publicName: "variant", isSignal: true, isRequired: false, transformFunction: null }, version: { classPropertyName: "version", publicName: "version", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: "@let versionValue = version();\n<footer>\n  <div class=\"footer-main\" [ngClass]=\"'footer-' + variant()\">\n    <div class=\"footer-main-bottom\">\n      <small class=\"copyright\">Copyright &copy; {{ currentYear }} Scania</small>\n      @if (versionValue) {\n        <small class=\"version\">Version: {{ versionValue }}</small>\n      }\n      <div class=\"brand\"></div>\n    </div>\n  </div>\n</footer>\n", styles: [":host{display:grid}.footer-main{background-color:var(--tds-footer-main-background);padding:0 40px}.footer-main .footer-main-bottom{padding:40px 0;display:flex;align-items:center;justify-content:space-between;border-top:1px solid var(--tds-footer-main-divider)}.footer-main .footer-main-bottom .copyright,.footer-main .footer-main-bottom .version{margin:0;font:var(--tds-detail-02);letter-spacing:var(--tds-detail-02-ls);color:var(--tds-footer-main-copyright)}.footer-main .footer-main-bottom .version{font-size:smaller;margin-left:auto;margin-right:40px}.footer-main .footer-main-bottom .brand{background-image:var(--tds-background-image-scania-wordmark-white-svg);background-repeat:no-repeat;background-size:117px;background-position:right center;width:117px;height:20px}.footer-main.footer-small .footer-main-bottom{padding:20px 0}.footer-main.footer-small .footer-main-bottom .copyright{font:var(--tds-detail-05);letter-spacing:var(--tds-detail-05-ls)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TaeFooterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tae-footer', imports: [CommonModule], standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, template: "@let versionValue = version();\n<footer>\n  <div class=\"footer-main\" [ngClass]=\"'footer-' + variant()\">\n    <div class=\"footer-main-bottom\">\n      <small class=\"copyright\">Copyright &copy; {{ currentYear }} Scania</small>\n      @if (versionValue) {\n        <small class=\"version\">Version: {{ versionValue }}</small>\n      }\n      <div class=\"brand\"></div>\n    </div>\n  </div>\n</footer>\n", styles: [":host{display:grid}.footer-main{background-color:var(--tds-footer-main-background);padding:0 40px}.footer-main .footer-main-bottom{padding:40px 0;display:flex;align-items:center;justify-content:space-between;border-top:1px solid var(--tds-footer-main-divider)}.footer-main .footer-main-bottom .copyright,.footer-main .footer-main-bottom .version{margin:0;font:var(--tds-detail-02);letter-spacing:var(--tds-detail-02-ls);color:var(--tds-footer-main-copyright)}.footer-main .footer-main-bottom .version{font-size:smaller;margin-left:auto;margin-right:40px}.footer-main .footer-main-bottom .brand{background-image:var(--tds-background-image-scania-wordmark-white-svg);background-repeat:no-repeat;background-size:117px;background-position:right center;width:117px;height:20px}.footer-main.footer-small .footer-main-bottom{padding:20px 0}.footer-main.footer-small .footer-main-bottom .copyright{font:var(--tds-detail-05);letter-spacing:var(--tds-detail-05-ls)}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFlLWZvb3Rlci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3RlZ2VsLWFuZ3VsYXItZXh0ZW5zaW9ucy9zcmMvbGliL2NvbXBvbmVudHMvdGFlLWZvb3Rlci90YWUtZm9vdGVyLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvdGVnZWwtYW5ndWxhci1leHRlbnNpb25zL3NyYy9saWIvY29tcG9uZW50cy90YWUtZm9vdGVyL3RhZS1mb290ZXIuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFFMUU7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFTSCxNQUFNLE9BQU8sa0JBQWtCO0lBQzdCOzs7Ozs7O09BT0c7SUFFTSxPQUFPLEdBQUcsS0FBSyxDQUFxQixRQUFRLENBQUMsQ0FBQztJQUN2RDs7Ozs7T0FLRztJQUNNLE9BQU8sR0FBRyxLQUFLLEVBQXNCLENBQUM7SUFFL0M7O09BRUc7SUFDTSxXQUFXLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQyxXQUFXLEVBQUUsQ0FBQzt3R0F0QnJDLGtCQUFrQjs0RkFBbEIsa0JBQWtCLDhVQzFCL0IsMFpBWUEscy9CRFFZLFlBQVk7OzRGQU1YLGtCQUFrQjtrQkFSOUIsU0FBUzsrQkFDRSxZQUFZLFdBQ2IsQ0FBQyxZQUFZLENBQUMsY0FDWCxJQUFJLG1CQUdDLHVCQUF1QixDQUFDLE1BQU0iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENvbXBvbmVudCwgaW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiBBbiBlbmhhbmNlZCBzdGFuZGFsb25lIGZvb3RlciBjb21wb25lbnQgYmFzZWQgb24gdGhlIFRlZ2VsIGBUZHNGb290ZXJDb21wb25lbnRgLlxuICpcbiAqIGBUYWVGb290ZXJDb21wb25lbnRgIG1haW50YWlucyB0aGUgc2FtZSB2aXN1YWwgc3R5bGUgYXMgdGhlIG9yaWdpbmFsXG4gKiBUZWdlbCBmb290ZXIsIGJ1dCBhZGRzIHR3byBrZXkgaW1wcm92ZW1lbnRzOlxuICpcbiAqIC0gQSAqKmNvbXBhY3Qg4oCcc21hbGzigJ0gdmFyaWFudCoqIGZvciBsYXlvdXRzIHdoZXJlIHZlcnRpY2FsIHNwYWNlIGlzIGxpbWl0ZWQuXG4gKiAtIE9wdGlvbmFsICoqdmVyc2lvbiBkaXNwbGF5KiosIGFsbG93aW5nIGFwcGxpY2F0aW9ucyB0byBzaG93IHRoZWlyXG4gKiAgIGJ1aWxkIG9yIHJlbGVhc2UgdmVyc2lvbiBkaXJlY3RseSBpbiB0aGUgZm9vdGVyLlxuICpcbiAqIEV4YW1wbGU6XG4gKiBgYGBodG1sXG4gKiA8dGFlLWZvb3RlciB2YXJpYW50PVwic21hbGxcIiB2ZXJzaW9uPVwidjEuMC4wXCIgLz5cbiAqIGBgYFxuICovXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICd0YWUtZm9vdGVyJyxcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIHRlbXBsYXRlVXJsOiAnLi90YWUtZm9vdGVyLmNvbXBvbmVudC5odG1sJyxcbiAgc3R5bGVVcmxzOiBbJy4vdGFlLWZvb3Rlci5jb21wb25lbnQuc2NzcyddLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbn0pXG5leHBvcnQgY2xhc3MgVGFlRm9vdGVyQ29tcG9uZW50IHtcbiAgLyoqXG4gICAqIERldGVybWluZXMgdGhlIHZpc3VhbCBsYXlvdXQgb2YgdGhlIGZvb3Rlci5cbiAgICpcbiAgICogLSBgXCJub3JtYWxcImAgZGlzcGxheXMgdGhlIHN0YW5kYXJkIGZvb3RlciBsYXlvdXQgKGFsaWduZWQgdG8gdGRzLWZvb3RlcilcbiAgICogLSBgXCJzbWFsbFwiYCBwcm9kdWNlcyBhIG1vcmUgY29tcGFjdCB2ZXJzaW9uIHN1aXRhYmxlIGZvciB0aWdodCBsYXlvdXRzXG4gICAqXG4gICAqIEBkZWZhdWx0ICdub3JtYWwnXG4gICAqL1xuXG4gIHJlYWRvbmx5IHZhcmlhbnQgPSBpbnB1dDwnbm9ybWFsJyB8ICdzbWFsbCc+KCdub3JtYWwnKTtcbiAgLyoqXG4gICAqIE9wdGlvbmFsIGFwcGxpY2F0aW9uIHZlcnNpb24gc3RyaW5nIHRvIGRpc3BsYXkgaW4gdGhlIGZvb3Rlci5cbiAgICpcbiAgICogV2hlbiBwcm92aWRlZCwgaXQgYXBwZWFycyBsZWZ0IG9mIHRoZSBTY2FuaWEgbG9nby5cbiAgICogSWYgb21pdHRlZCBvciBgdW5kZWZpbmVkYCwgdGhlIHZlcnNpb24gc2VjdGlvbiBpcyBub3Qgc2hvd24uXG4gICAqL1xuICByZWFkb25seSB2ZXJzaW9uID0gaW5wdXQ8c3RyaW5nIHwgdW5kZWZpbmVkPigpO1xuXG4gIC8qKlxuICAgKiBUaGUgY3VycmVudCB5ZWFyIHVzZWQgaW4gdGhlIGNvcHlyaWdodCBzZWN0aW9uLlxuICAgKi9cbiAgcmVhZG9ubHkgY3VycmVudFllYXIgPSBuZXcgRGF0ZSgpLmdldEZ1bGxZZWFyKCk7XG59XG4iLCJAbGV0IHZlcnNpb25WYWx1ZSA9IHZlcnNpb24oKTtcbjxmb290ZXI+XG4gIDxkaXYgY2xhc3M9XCJmb290ZXItbWFpblwiIFtuZ0NsYXNzXT1cIidmb290ZXItJyArIHZhcmlhbnQoKVwiPlxuICAgIDxkaXYgY2xhc3M9XCJmb290ZXItbWFpbi1ib3R0b21cIj5cbiAgICAgIDxzbWFsbCBjbGFzcz1cImNvcHlyaWdodFwiPkNvcHlyaWdodCAmY29weTsge3sgY3VycmVudFllYXIgfX0gU2NhbmlhPC9zbWFsbD5cbiAgICAgIEBpZiAodmVyc2lvblZhbHVlKSB7XG4gICAgICAgIDxzbWFsbCBjbGFzcz1cInZlcnNpb25cIj5WZXJzaW9uOiB7eyB2ZXJzaW9uVmFsdWUgfX08L3NtYWxsPlxuICAgICAgfVxuICAgICAgPGRpdiBjbGFzcz1cImJyYW5kXCI+PC9kaXY+XG4gICAgPC9kaXY+XG4gIDwvZGl2PlxuPC9mb290ZXI+XG4iXX0=

package/esm2022/lib/directives/hard-refresh.directive.mjs

@@ -0,0 +1,83 @@
+import { Directive, input } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { filter, map, pairwise, scan, startWith, Subject, throttleTime, timestamp, } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Directive that triggers a hard page refresh when the host element is clicked
+ * a specified number of times within a configurable time window.
+ *
+ * This is useful for adding developer-oriented shortcuts, diagnostics entry points,
+ * hidden "triple-click to reload" behaviors, or fallback mechanisms in production.
+ *
+ * Usage:
+ * ```html
+ * <div taeHardRefresh [clicksRequired]="3" [clickWindowMs]="500">...</div>
+ * ```
+ */
+export class HardRefreshDirective {
+    /**
+     * The number of rapid consecutive clicks required to trigger a hard refresh.
+     * A "rapid" click is one that occurs within `clickWindowMs` of the previous click.
+     *
+     * @default 3
+     */
+    clicksRequired = input(3);
+    /**
+     * The maximum time interval (in milliseconds) allowed between consecutive clicks
+     * for them to be considered part of the same "streak".
+     *
+     * If the interval between two clicks exceeds this value, the streak resets.
+     *
+     * @default 500
+     */
+    clickWindowMs = input(500);
+    /**
+     * Internal click event stream used to build the rapid-click detection pipeline.
+     * Emits one value per host click (via the `(click)` host listener).
+     */
+    clicks$ = new Subject();
+    constructor() {
+        /**
+         * Rapid-click detection pipeline:
+         *
+         * - Timestamps each click.
+         * - Compares consecutive timestamps to determine whether they fall within the
+         *   configured `clickWindowMs` threshold.
+         * - Maintains a streak count using a reducer (`scan`).
+         * - Emits once the streak count reaches or exceeds `clicksRequired`.
+         * - Uses `throttleTime` to prevent duplicate triggers within the same burst.
+         */
+        this.clicks$
+            .pipe(takeUntilDestroyed(), 
+        // Turn click events into raw timestamps (epoch ms)
+        timestamp(), map((t) => t.timestamp), 
+        // Work in pairs: [previousTimestamp, currentTimestamp]
+        startWith(0), pairwise(), 
+        // Maintain a streak of clicks within the time window
+        scan((acc, [prev, curr]) => curr - prev <= this.clickWindowMs() ? acc + 1 : 1, 0), 
+        // Only continue when we reach the threshold number of clicks
+        filter((streak) => streak >= this.clicksRequired()), 
+        // Avoid multiple triggers for the same "burst" of clicks
+        throttleTime(this.clickWindowMs(), undefined, {
+            leading: true,
+            trailing: false,
+        }))
+            .subscribe(() => {
+            // Reload the window
+            window.location.reload();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: HardRefreshDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.17", type: HardRefreshDirective, isStandalone: true, selector: "[taeHardRefresh]", inputs: { clicksRequired: { classPropertyName: "clicksRequired", publicName: "clicksRequired", isSignal: true, isRequired: false, transformFunction: null }, clickWindowMs: { classPropertyName: "clickWindowMs", publicName: "clickWindowMs", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "click": "clicks$.next()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: HardRefreshDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[taeHardRefresh]',
+                    standalone: true,
+                    host: {
+                        '(click)': 'clicks$.next()',
+                    },
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFyZC1yZWZyZXNoLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvdGVnZWwtYW5ndWxhci1leHRlbnNpb25zL3NyYy9saWIvZGlyZWN0aXZlcy9oYXJkLXJlZnJlc2guZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ2pELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ2hFLE9BQU8sRUFDTCxNQUFNLEVBQ04sR0FBRyxFQUNILFFBQVEsRUFDUixJQUFJLEVBQ0osU0FBUyxFQUNULE9BQU8sRUFDUCxZQUFZLEVBQ1osU0FBUyxHQUNWLE1BQU0sTUFBTSxDQUFDOztBQUVkOzs7Ozs7Ozs7OztHQVdHO0FBUUgsTUFBTSxPQUFPLG9CQUFvQjtJQUMvQjs7Ozs7T0FLRztJQUNNLGNBQWMsR0FBRyxLQUFLLENBQVMsQ0FBQyxDQUFDLENBQUM7SUFFM0M7Ozs7Ozs7T0FPRztJQUNNLGFBQWEsR0FBRyxLQUFLLENBQVMsR0FBRyxDQUFDLENBQUM7SUFFNUM7OztPQUdHO0lBQ2dCLE9BQU8sR0FBRyxJQUFJLE9BQU8sRUFBUSxDQUFDO0lBRWpEO1FBQ0U7Ozs7Ozs7OztXQVNHO1FBQ0gsSUFBSSxDQUFDLE9BQU87YUFDVCxJQUFJLENBQ0gsa0JBQWtCLEVBQUU7UUFDcEIsbURBQW1EO1FBQ25ELFNBQVMsRUFBRSxFQUNYLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztRQUN2Qix1REFBdUQ7UUFDdkQsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUNaLFFBQVEsRUFBRTtRQUNWLHFEQUFxRDtRQUNyRCxJQUFJLENBQ0YsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLEVBQUUsRUFBRSxDQUNwQixJQUFJLEdBQUcsSUFBSSxJQUFJLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQyxDQUFDLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUNuRCxDQUFDLENBQ0Y7UUFDRCw2REFBNkQ7UUFDN0QsTUFBTSxDQUFDLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxNQUFNLElBQUksSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBQ25ELHlEQUF5RDtRQUN6RCxZQUFZLENBQUMsSUFBSSxDQUFDLGFBQWEsRUFBRSxFQUFFLFNBQVMsRUFBRTtZQUM1QyxPQUFPLEVBQUUsSUFBSTtZQUNiLFFBQVEsRUFBRSxLQUFLO1NBQ2hCLENBQUMsQ0FDSDthQUNBLFNBQVMsQ0FBQyxHQUFHLEVBQUU7WUFDZCxvQkFBb0I7WUFDcEIsTUFBTSxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUMzQixDQUFDLENBQUMsQ0FBQztJQUNQLENBQUM7d0dBL0RVLG9CQUFvQjs0RkFBcEIsb0JBQW9COzs0RkFBcEIsb0JBQW9CO2tCQVBoQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxrQkFBa0I7b0JBQzVCLFVBQVUsRUFBRSxJQUFJO29CQUNoQixJQUFJLEVBQUU7d0JBQ0osU0FBUyxFQUFFLGdCQUFnQjtxQkFDNUI7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIGlucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyB0YWtlVW50aWxEZXN0cm95ZWQgfSBmcm9tICdAYW5ndWxhci9jb3JlL3J4anMtaW50ZXJvcCc7XG5pbXBvcnQge1xuICBmaWx0ZXIsXG4gIG1hcCxcbiAgcGFpcndpc2UsXG4gIHNjYW4sXG4gIHN0YXJ0V2l0aCxcbiAgU3ViamVjdCxcbiAgdGhyb3R0bGVUaW1lLFxuICB0aW1lc3RhbXAsXG59IGZyb20gJ3J4anMnO1xuXG4vKipcbiAqIERpcmVjdGl2ZSB0aGF0IHRyaWdnZXJzIGEgaGFyZCBwYWdlIHJlZnJlc2ggd2hlbiB0aGUgaG9zdCBlbGVtZW50IGlzIGNsaWNrZWRcbiAqIGEgc3BlY2lmaWVkIG51bWJlciBvZiB0aW1lcyB3aXRoaW4gYSBjb25maWd1cmFibGUgdGltZSB3aW5kb3cuXG4gKlxuICogVGhpcyBpcyB1c2VmdWwgZm9yIGFkZGluZyBkZXZlbG9wZXItb3JpZW50ZWQgc2hvcnRjdXRzLCBkaWFnbm9zdGljcyBlbnRyeSBwb2ludHMsXG4gKiBoaWRkZW4gXCJ0cmlwbGUtY2xpY2sgdG8gcmVsb2FkXCIgYmVoYXZpb3JzLCBvciBmYWxsYmFjayBtZWNoYW5pc21zIGluIHByb2R1Y3Rpb24uXG4gKlxuICogVXNhZ2U6XG4gKiBgYGBodG1sXG4gKiA8ZGl2IHRhZUhhcmRSZWZyZXNoIFtjbGlja3NSZXF1aXJlZF09XCIzXCIgW2NsaWNrV2luZG93TXNdPVwiNTAwXCI+Li4uPC9kaXY+XG4gKiBgYGBcbiAqL1xuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW3RhZUhhcmRSZWZyZXNoXScsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIGhvc3Q6IHtcbiAgICAnKGNsaWNrKSc6ICdjbGlja3MkLm5leHQoKScsXG4gIH0sXG59KVxuZXhwb3J0IGNsYXNzIEhhcmRSZWZyZXNoRGlyZWN0aXZlIHtcbiAgLyoqXG4gICAqIFRoZSBudW1iZXIgb2YgcmFwaWQgY29uc2VjdXRpdmUgY2xpY2tzIHJlcXVpcmVkIHRvIHRyaWdnZXIgYSBoYXJkIHJlZnJlc2guXG4gICAqIEEgXCJyYXBpZFwiIGNsaWNrIGlzIG9uZSB0aGF0IG9jY3VycyB3aXRoaW4gYGNsaWNrV2luZG93TXNgIG9mIHRoZSBwcmV2aW91cyBjbGljay5cbiAgICpcbiAgICogQGRlZmF1bHQgM1xuICAgKi9cbiAgcmVhZG9ubHkgY2xpY2tzUmVxdWlyZWQgPSBpbnB1dDxudW1iZXI+KDMpO1xuXG4gIC8qKlxuICAgKiBUaGUgbWF4aW11bSB0aW1lIGludGVydmFsIChpbiBtaWxsaXNlY29uZHMpIGFsbG93ZWQgYmV0d2VlbiBjb25zZWN1dGl2ZSBjbGlja3NcbiAgICogZm9yIHRoZW0gdG8gYmUgY29uc2lkZXJlZCBwYXJ0IG9mIHRoZSBzYW1lIFwic3RyZWFrXCIuXG4gICAqXG4gICAqIElmIHRoZSBpbnRlcnZhbCBiZXR3ZWVuIHR3byBjbGlja3MgZXhjZWVkcyB0aGlzIHZhbHVlLCB0aGUgc3RyZWFrIHJlc2V0cy5cbiAgICpcbiAgICogQGRlZmF1bHQgNTAwXG4gICAqL1xuICByZWFkb25seSBjbGlja1dpbmRvd01zID0gaW5wdXQ8bnVtYmVyPig1MDApO1xuXG4gIC8qKlxuICAgKiBJbnRlcm5hbCBjbGljayBldmVudCBzdHJlYW0gdXNlZCB0byBidWlsZCB0aGUgcmFwaWQtY2xpY2sgZGV0ZWN0aW9uIHBpcGVsaW5lLlxuICAgKiBFbWl0cyBvbmUgdmFsdWUgcGVyIGhvc3QgY2xpY2sgKHZpYSB0aGUgYChjbGljaylgIGhvc3QgbGlzdGVuZXIpLlxuICAgKi9cbiAgcHJvdGVjdGVkIHJlYWRvbmx5IGNsaWNrcyQgPSBuZXcgU3ViamVjdDx2b2lkPigpO1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIC8qKlxuICAgICAqIFJhcGlkLWNsaWNrIGRldGVjdGlvbiBwaXBlbGluZTpcbiAgICAgKlxuICAgICAqIC0gVGltZXN0YW1wcyBlYWNoIGNsaWNrLlxuICAgICAqIC0gQ29tcGFyZXMgY29uc2VjdXRpdmUgdGltZXN0YW1wcyB0byBkZXRlcm1pbmUgd2hldGhlciB0aGV5IGZhbGwgd2l0aGluIHRoZVxuICAgICAqICAgY29uZmlndXJlZCBgY2xpY2tXaW5kb3dNc2AgdGhyZXNob2xkLlxuICAgICAqIC0gTWFpbnRhaW5zIGEgc3RyZWFrIGNvdW50IHVzaW5nIGEgcmVkdWNlciAoYHNjYW5gKS5cbiAgICAgKiAtIEVtaXRzIG9uY2UgdGhlIHN0cmVhayBjb3VudCByZWFjaGVzIG9yIGV4Y2VlZHMgYGNsaWNrc1JlcXVpcmVkYC5cbiAgICAgKiAtIFVzZXMgYHRocm90dGxlVGltZWAgdG8gcHJldmVudCBkdXBsaWNhdGUgdHJpZ2dlcnMgd2l0aGluIHRoZSBzYW1lIGJ1cnN0LlxuICAgICAqL1xuICAgIHRoaXMuY2xpY2tzJFxuICAgICAgLnBpcGUoXG4gICAgICAgIHRha2VVbnRpbERlc3Ryb3llZCgpLFxuICAgICAgICAvLyBUdXJuIGNsaWNrIGV2ZW50cyBpbnRvIHJhdyB0aW1lc3RhbXBzIChlcG9jaCBtcylcbiAgICAgICAgdGltZXN0YW1wKCksXG4gICAgICAgIG1hcCgodCkgPT4gdC50aW1lc3RhbXApLFxuICAgICAgICAvLyBXb3JrIGluIHBhaXJzOiBbcHJldmlvdXNUaW1lc3RhbXAsIGN1cnJlbnRUaW1lc3RhbXBdXG4gICAgICAgIHN0YXJ0V2l0aCgwKSxcbiAgICAgICAgcGFpcndpc2UoKSxcbiAgICAgICAgLy8gTWFpbnRhaW4gYSBzdHJlYWsgb2YgY2xpY2tzIHdpdGhpbiB0aGUgdGltZSB3aW5kb3dcbiAgICAgICAgc2NhbihcbiAgICAgICAgICAoYWNjLCBbcHJldiwgY3Vycl0pID0+XG4gICAgICAgICAgICBjdXJyIC0gcHJldiA8PSB0aGlzLmNsaWNrV2luZG93TXMoKSA/IGFjYyArIDEgOiAxLFxuICAgICAgICAgIDBcbiAgICAgICAgKSxcbiAgICAgICAgLy8gT25seSBjb250aW51ZSB3aGVuIHdlIHJlYWNoIHRoZSB0aHJlc2hvbGQgbnVtYmVyIG9mIGNsaWNrc1xuICAgICAgICBmaWx0ZXIoKHN0cmVhaykgPT4gc3RyZWFrID49IHRoaXMuY2xpY2tzUmVxdWlyZWQoKSksXG4gICAgICAgIC8vIEF2b2lkIG11bHRpcGxlIHRyaWdnZXJzIGZvciB0aGUgc2FtZSBcImJ1cnN0XCIgb2YgY2xpY2tzXG4gICAgICAgIHRocm90dGxlVGltZSh0aGlzLmNsaWNrV2luZG93TXMoKSwgdW5kZWZpbmVkLCB7XG4gICAgICAgICAgbGVhZGluZzogdHJ1ZSxcbiAgICAgICAgICB0cmFpbGluZzogZmFsc2UsXG4gICAgICAgIH0pXG4gICAgICApXG4gICAgICAuc3Vic2NyaWJlKCgpID0+IHtcbiAgICAgICAgLy8gUmVsb2FkIHRoZSB3aW5kb3dcbiAgICAgICAgd2luZG93LmxvY2F0aW9uLnJlbG9hZCgpO1xuICAgICAgfSk7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,161 @@
+import { inject, Injectable, InjectionToken, makeEnvironmentProviders, provideAppInitializer, } from '@angular/core';
+import { catchError, defer, firstValueFrom, from, map, of, switchMap, tap, } from 'rxjs';
+import { parseEnvFile } from '../core/parse-env-file';
+import * as i0 from "@angular/core";
+/**
+ * Builds styled console arguments for RuntimeConfig logs.
+ *
+ * The returned tuple can be spread directly into `console.log`,
+ * allowing the browser to render a colored `[RuntimeConfig]` prefix
+ * while preserving the original caller location in DevTools.
+ *
+ * Example:
+ * ```ts
+ * console.log(...rcArgs('Runtime overrides loaded.'));
+ * ```
+ *
+ * @param msg - The message text to append after the colored prefix.
+ * @returns A tuple of arguments (`[format, style, reset]`) for `console.log`.
+ */
+const rcArgs = (msg) => [
+    '%c[RuntimeConfig]%c ' + msg,
+    'color:#0cf;',
+    '',
+];
+/**
+ * Registers providers that:
+ * - Fetch a runtime `.env` file at startup,
+ * - Parse it to a deep-partial structure via the kit,
+ * - Enforce runtime-required keys when appropriate,
+ * - Merge with the static environment,
+ * - Validate the **final** configuration against the Zod schema,
+ * - Expose the resulting config via a generated `InjectionToken`.
+ *
+ * @typeParam S - Zod schema type describing the full config shape.
+ * @typeParam K - List of runtime-required top-level keys.
+ *
+ * @param kit
+ * The `EnvKit` created by `createEnvKit(schema, runtimeRequiredKeys)`.
+ *
+ * @param options
+ * Runtime loading behavior and DI token description. See {@link ProvideRuntimeConfigOptions}.
+ *
+ * @returns The `EnvironmentProviders` to be added to `appConfig.providers`,
+ *
+ * @remarks
+ * - This uses an Angular **functional app initializer** to perform the load step.
+ * - If the server returns an HTML SPA fallback (instead of the `.env` file), the provider
+ *   quietly uses the static environment (no runtime overrides).
+ */
+export function provideRuntimeConfig(kit, staticEnv, { envPath = '/env/runtime.env', debug = false, stopOnError = true, token, } = {}) {
+    // Typed token used to expose the final validated config via DI.
+    const configToken = token ?? new InjectionToken('ENV_CONFIG');
+    /**
+     * Angular service that handles fetching, parsing, validating, and caching
+     * of the runtime environment configuration.
+     */
+    class RuntimeConfigService {
+        // Cached instance of the validated configuration.
+        config;
+        /**
+         * Loads, parses, merges and validates the runtime configuration.
+         * Returns an `Observable<ConfigShape>` and caches the final result.
+         */
+        load() {
+            return defer(() => from(fetch(envPath).then((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 res.text();
+            })).pipe(
+            // 1. SPA fallback guard (server returned HTML instead of .env)
+            map((raw) => {
+                const trimmed = raw.trim();
+                const looksHtml = /^\s*<!doctype/i.test(trimmed) || /^\s*<html[\s>]/i.test(trimmed);
+                if (looksHtml) {
+                    if (debug) {
+                        console.log(...rcArgs('No runtime environment file detected, using static environment only.'));
+                    }
+                    // Signal “no runtime.env, use static only”
+                    return null;
+                }
+                return raw;
+            }), tap((v) => {
+                if (!debug)
+                    return;
+                console.log(...rcArgs(v === null
+                    ? 'No runtime environment file defined, using static environment'
+                    : 'Runtime environment file loaded, applying overrides.'));
+            }), 
+            // 2. Either continue the pipe or return defaults
+            switchMap((raw) => {
+                if (raw === null) {
+                    return from(kit.mergeAndValidateAsync(staticEnv)).pipe(tap((cfg) => (this.config = cfg)));
+                }
+                // 3. Parse raw `.env` text -> object, then deep-partial-parse via kit
+                const runtimeConfigRaw = parseEnvFile(raw);
+                return from(kit.parseRuntimeOverridesAsync(runtimeConfigRaw)).pipe(tap((overrides) => {
+                    if (debug)
+                        console.log(...rcArgs('Runtime config (parsed):'), overrides);
+                }), 
+                // 4. Merge static + overrides and validate the final config (async)
+                switchMap((overrides) => from(kit.mergeAndValidateAsync(staticEnv, overrides))), 
+                // 5. Cache the validated config for synchronous access later
+                tap((mergedConfig) => {
+                    if (debug)
+                        console.log(...rcArgs('Merged config:'), mergedConfig);
+                    this.config = mergedConfig;
+                }));
+            }), 
+            // 6. Error handling: fail fast or gracefully fall back to static-only
+            catchError((err) => {
+                if (stopOnError) {
+                    // Reject app initialization (recommended for production)
+                    throw err;
+                }
+                console.error(...rcArgs('Error occurred while loading runtime config:'), err);
+                return of(this.useDefaults());
+            })));
+        }
+        /**
+         * Returns the current configuration.
+         * If not yet loaded, returns a validated static-only configuration.
+         */
+        get() {
+            if (!this.config) {
+                throw new Error('RuntimeConfigService.get() called before configuration was loaded. ' +
+                    'Ensure provideAppInitializer waits for RuntimeConfigService.load().');
+            }
+            return this.config;
+        }
+        /**
+         * Sets the current configuration to a validated static-only configuration
+         * Used when the runtime `.env` file is missing.
+         */
+        useDefaults() {
+            // Note: this uses the static env; merge+validate is performed in `get()` if needed.
+            this.config ??= staticEnv;
+            return this.config;
+        }
+        static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: RuntimeConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+        static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: RuntimeConfigService, providedIn: 'root' });
+    }
+    i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: RuntimeConfigService, decorators: [{
+                type: Injectable,
+                args: [{ providedIn: 'root' }]
+            }] });
+    // Register the service + initializer + token exposure with Angular DI.
+    return makeEnvironmentProviders([
+        RuntimeConfigService,
+        // Angular 19+ functional initializer (subscribes to the load Observable)
+        // Using firstValueFrom to enforece "await until loaded" semantics
+        provideAppInitializer(() => firstValueFrom(inject(RuntimeConfigService).load())),
+        // Expose the final validated config via the generated token
+        {
+            provide: configToken,
+            useFactory: () => inject(RuntimeConfigService).get(),
+        },
+    ]);
+}
+//# 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"]}

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

@@ -0,0 +1,44 @@
+import { makeEnvironmentProviders, } from '@angular/core';
+/**
+ * Registers providers that:
+ * - Expose a **static** environment configuration object via Angular DI,
+ * - Perform **no** runtime `.env` fetching or asynchronous initialization,
+ * - Mirror Angular’s standard build-time pattern:
+ *
+ *     { provide: SOME_TOKEN, useValue: environment }
+ *
+ * This is intended for applications that:
+ * - Use only `environment.ts` build-time configuration,
+ * - Do not require runtime overrides or external `.env` files,
+ * - Wish to keep bootstrap logic minimal and predictable,
+ * - Or are running in unit tests where a fixed static config is sufficient.
+ *
+ * @typeParam T - The shape of the static configuration object.
+ *
+ * @param env
+ * The static configuration instance to expose via DI. Defaults to an empty
+ * object if omitted, enabling callers to provide minimal configuration
+ * without boilerplate.
+ *
+ * @param options
+ * A `ProvideStaticConfigOptions<T>` containing the **required**
+ * `InjectionToken<T>` under which the configuration will be registered.
+ * Angular DI resolves providers solely by token instance identity, so the
+ * caller must supply the exact token that consumers will inject.
+ *
+ * @returns The `EnvironmentProviders` to be added to `appConfig.providers`.
+ *
+ * @remarks
+ * The static provider is intentionally minimal, offering a lightweight
+ * counterpart to `provideRuntimeConfig` for apps that rely on build-time
+ * environment values only.
+ */
+export function provideStaticConfig(env = {}, options) {
+    return makeEnvironmentProviders([
+        {
+            provide: options.token,
+            useValue: env,
+        },
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/env/core/create-env-kit.mjs

@@ -0,0 +1,81 @@
+import { zx } from '@traversable/zod';
+/**
+ * Builds a **type-safe environment kit** around a Zod schema.
+ *
+ * This utility encapsulates all environment configuration logic in a reusable,
+ * strongly-typed structure that:
+ * - Validates **deep-partial** runtime overrides using `zx.deepPartial(schema)`.
+ * - Ensures that **runtime-required keys** are provided when `production=true`.
+ * - Merges static defaults with runtime overrides and validates the **final config** asynchronously.
+ *
+ * @typeParam S - The Zod schema type describing the full environment configuration.
+ * @typeParam K - The list of top-level keys that must be supplied at runtime in production builds.
+ *
+ * @param params.schema - The full Zod schema defining the configuration structure.
+ * @param params.runtimeRequiredKeys - Keys that must be present in runtime overrides for production.
+ *
+ * @returns A fully-typed {@link EnvKit} instance exposing validation helpers, runtime parsers, and type tokens.
+ */
+export function createEnvKit(params) {
+    const { schema, runtimeRequiredKeys } = params;
+    /** Deep-partial schema — allows validation of incomplete runtime overrides. */
+    const runtimeOverridesSchema = zx.deepPartial(schema);
+    /**
+     * Parses a raw `.env` object into a **deep-partial** structure matching the schema.
+     * @param raw - The raw key-value object parsed from a `.env` file.
+     * @returns A validated deep-partial configuration matching the schema shape.
+     * @throws ZodError if the structure is invalid.
+     */
+    function parseRuntimeOverridesAsync(raw) {
+        return runtimeOverridesSchema.parseAsync(raw);
+    }
+    /**
+     * Validates that all runtime-required keys are defined when `production=true`.
+     * Prevents missing values from being silently filled from static defaults.
+     *
+     * @param overrides - The runtime overrides to inspect.
+     * @param production - Whether the environment is running in production mode.
+     * @throws Error if any runtime-required key is missing.
+     */
+    function ensureRuntimeKeysPresent(overrides, production) {
+        if (!production)
+            return;
+        const missing = runtimeRequiredKeys.filter((k) => overrides[k] === undefined);
+        console.log('Overrides', overrides);
+        if (missing.length) {
+            throw new Error(`Missing required runtime overrides for production: ${missing.join(', ')}`);
+        }
+    }
+    /**
+     * Merges the provided static environment with runtime overrides,
+     * enforces runtime key presence when necessary, and validates the
+     * **final merged configuration** against the full schema.
+     *
+     * @param staticEnv - The static environment configuration (dev or prod).
+     * @param overrides - The runtime overrides to merge in.
+     * @returns A fully validated, strongly typed configuration object.
+     * @throws ZodError if validation fails, or Error if required keys are missing in production.
+     */
+    function mergeAndValidateAsync(staticEnv, overrides = {}) {
+        // Determine production mode; runtime override takes precedence if defined
+        const effectiveProduction = (overrides['production'] ?? staticEnv.production) === true;
+        ensureRuntimeKeysPresent(overrides, effectiveProduction);
+        // Validate the merged result asynchronously with the full schema
+        return schema.parseAsync({ ...staticEnv, ...overrides });
+    }
+    return {
+        /** The full Zod schema provided by the consumer. */
+        schema,
+        /** Deep-partial schema used for validating runtime overrides (via `zx.deepPartial`). */
+        runtimeOverridesSchema,
+        /** Keys that must be provided in runtime overrides when `production=true`. */
+        runtimeRequiredKeys,
+        /** Parses a raw `.env` object into deep-partial runtime overrides (async). */
+        parseRuntimeOverridesAsync,
+        /** Merges static + runtime configs and validates the final schema (async). */
+        mergeAndValidateAsync,
+        /** Type tokens for compile-time inference; erased at runtime. */
+        types: {},
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-env-kit.js","sourceRoot":"","sources":["../../../../../../../libs/tegel-angular-extensions/src/lib/env/core/create-env-kit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAWtC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,YAAY,CAG1B,MAKD;IACC,MAAM,EAAE,MAAM,EAAE,mBAAmB,EAAE,GAAG,MAAM,CAAC;IAK/C,+EAA+E;IAC/E,MAAM,sBAAsB,GAAG,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAEtD;;;;;OAKG;IACH,SAAS,0BAA0B,CACjC,GAA4B;QAE5B,OAAO,sBAAsB,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IAChD,CAAC;IAED;;;;;;;OAOG;IACH,SAAS,wBAAwB,CAC/B,SAA6B,EAC7B,UAAmB;QAEnB,IAAI,CAAC,UAAU;YAAE,OAAO;QACxB,MAAM,OAAO,GACX,mBACD,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC;QAE5C,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;QAEpC,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CACb,sDAAsD,OAAO,CAAC,IAAI,CAChE,IAAI,CACL,EAAE,CACJ,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,SAAS,qBAAqB,CAC5B,SAA2D,EAC3D,YAAgC,EAAE;QAElC,0EAA0E;QAC1E,MAAM,mBAAmB,GACvB,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,SAAS,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;QAE7D,wBAAwB,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QAEzD,iEAAiE;QACjE,OAAO,MAAM,CAAC,UAAU,CAAC,EAAE,GAAG,SAAS,EAAE,GAAG,SAAS,EAAE,CAAC,CAAC;IAC3D,CAAC;IAED,OAAO;QACL,oDAAoD;QACpD,MAAM;QAEN,wFAAwF;QACxF,sBAAsB;QAEtB,8EAA8E;QAC9E,mBAAmB;QAEnB,8EAA8E;QAC9E,0BAA0B;QAE1B,8EAA8E;QAC9E,qBAAqB;QAErB,iEAAiE;QACjE,KAAK,EAAE,EAON;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { zx } from '@traversable/zod';\nimport { z } from 'zod';\nimport {\n  DevDefaultsFrom,\n  DevStaticEnvFrom,\n  EnvKit,\n  ProdStaticEnvFrom,\n  SchemaOutput,\n  StaticEnvFrom,\n} from './env-types';\n\n/**\n * Builds a **type-safe environment kit** around a Zod schema.\n *\n * This utility encapsulates all environment configuration logic in a reusable,\n * strongly-typed structure that:\n * - Validates **deep-partial** runtime overrides using `zx.deepPartial(schema)`.\n * - Ensures that **runtime-required keys** are provided when `production=true`.\n * - Merges static defaults with runtime overrides and validates the **final config** asynchronously.\n *\n * @typeParam S - The Zod schema type describing the full environment configuration.\n * @typeParam K - The list of top-level keys that must be supplied at runtime in production builds.\n *\n * @param params.schema - The full Zod schema defining the configuration structure.\n * @param params.runtimeRequiredKeys - Keys that must be present in runtime overrides for production.\n *\n * @returns A fully-typed {@link EnvKit} instance exposing validation helpers, runtime parsers, and type tokens.\n */\nexport function createEnvKit<\n  S extends z.ZodObject<z.ZodRawShape>,\n  K extends readonly (keyof z.output<S>)[]\n>(params: {\n  /** The full Zod schema describing the app's configuration shape. */\n  schema: S;\n  /** Keys that must be provided at runtime when `production=true`. */\n  runtimeRequiredKeys: K;\n}): EnvKit<S, K> {\n  const { schema, runtimeRequiredKeys } = params;\n\n  /** Concrete schema output type for convenience inside this factory. */\n  type EnvConfig = SchemaOutput<S>;\n\n  /** Deep-partial schema — allows validation of incomplete runtime overrides. */\n  const runtimeOverridesSchema = zx.deepPartial(schema);\n\n  /**\n   * Parses a raw `.env` object into a **deep-partial** structure matching the schema.\n   * @param raw - The raw key-value object parsed from a `.env` file.\n   * @returns A validated deep-partial configuration matching the schema shape.\n   * @throws ZodError if the structure is invalid.\n   */\n  function parseRuntimeOverridesAsync(\n    raw: Record<string, unknown>\n  ): Promise<Partial<EnvConfig>> {\n    return runtimeOverridesSchema.parseAsync(raw);\n  }\n\n  /**\n   * Validates that all runtime-required keys are defined when `production=true`.\n   * Prevents missing values from being silently filled from static defaults.\n   *\n   * @param overrides - The runtime overrides to inspect.\n   * @param production - Whether the environment is running in production mode.\n   * @throws Error if any runtime-required key is missing.\n   */\n  function ensureRuntimeKeysPresent(\n    overrides: Partial<EnvConfig>,\n    production: boolean\n  ): void {\n    if (!production) return;\n    const missing = (\n      runtimeRequiredKeys as readonly (keyof EnvConfig)[]\n    ).filter((k) => overrides[k] === undefined);\n\n    console.log('Overrides', overrides);\n\n    if (missing.length) {\n      throw new Error(\n        `Missing required runtime overrides for production: ${missing.join(\n          ', '\n        )}`\n      );\n    }\n  }\n\n  /**\n   * Merges the provided static environment with runtime overrides,\n   * enforces runtime key presence when necessary, and validates the\n   * **final merged configuration** against the full schema.\n   *\n   * @param staticEnv - The static environment configuration (dev or prod).\n   * @param overrides - The runtime overrides to merge in.\n   * @returns A fully validated, strongly typed configuration object.\n   * @throws ZodError if validation fails, or Error if required keys are missing in production.\n   */\n  function mergeAndValidateAsync(\n    staticEnv: DevStaticEnvFrom<S, K> | ProdStaticEnvFrom<S, K>,\n    overrides: Partial<EnvConfig> = {}\n  ): Promise<EnvConfig> {\n    // Determine production mode; runtime override takes precedence if defined\n    const effectiveProduction =\n      (overrides['production'] ?? staticEnv.production) === true;\n\n    ensureRuntimeKeysPresent(overrides, effectiveProduction);\n\n    // Validate the merged result asynchronously with the full schema\n    return schema.parseAsync({ ...staticEnv, ...overrides });\n  }\n\n  return {\n    /** The full Zod schema provided by the consumer. */\n    schema,\n\n    /** Deep-partial schema used for validating runtime overrides (via `zx.deepPartial`). */\n    runtimeOverridesSchema,\n\n    /** Keys that must be provided in runtime overrides when `production=true`. */\n    runtimeRequiredKeys,\n\n    /** Parses a raw `.env` object into deep-partial runtime overrides (async). */\n    parseRuntimeOverridesAsync,\n\n    /** Merges static + runtime configs and validates the final schema (async). */\n    mergeAndValidateAsync,\n\n    /** Type tokens for compile-time inference; erased at runtime. */\n    types: {} as {\n      EnvConfig: EnvConfig;\n      DevDefaults: DevDefaultsFrom<S, K>;\n      DevStaticEnv: DevStaticEnvFrom<S, K>;\n      ProdStaticEnv: ProdStaticEnvFrom<S, K>;\n      StaticEnv: StaticEnvFrom<S, K>;\n      RuntimeRequired: K[number];\n    },\n  };\n}\n"]}

package/esm2022/lib/env/core/env-types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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