@ui5/webcomponents-ngx 0.1.1 → 0.1.2-rc.1

package/esm2022/fiori/view-settings-dialog/index.mjs

@@ -0,0 +1,71 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, ElementRef, NgZone, ChangeDetectorRef, } from '@angular/core';
+import { ProxyInputs, ProxyMethods, ProxyOutputs, } from '@ui5/webcomponents-ngx/utils';
+import '@ui5/webcomponents-fiori/dist/ViewSettingsDialog.js';
+import * as i0 from "@angular/core";
+// TS source file
+let ViewSettingsDialogComponent = class ViewSettingsDialogComponent {
+    constructor(c, elementRef, zone) {
+        this.c = c;
+        this.elementRef = elementRef;
+        this.zone = zone;
+        c.detach();
+    }
+    get element() {
+        return this.elementRef.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ViewSettingsDialogComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: ViewSettingsDialogComponent, isStandalone: true, selector: "ui5-view-settings-dialog", inputs: { effectiveDir: ["effective-dir", "effectiveDir"], isUi5Element: ["is-ui-5-element", "isUi5Element"], sortDescending: ["sort-descending", "sortDescending"] }, outputs: { beforeOpen: "ui5BeforeOpen", cancel: "ui5Cancel", confirm: "ui5Confirm" }, providers: [], exportAs: ["ui5ViewSettingsDialog"], ngImport: i0, template: `<ng-content></ng-content>`, isInline: true }); }
+};
+ViewSettingsDialogComponent = __decorate([
+    ProxyInputs(['effectiveDir', 'isUi5Element', 'sortDescending']),
+    ProxyOutputs(['beforeOpen', 'cancel', 'confirm']),
+    ProxyMethods([
+        '_render',
+        'attachInvalidate',
+        'define',
+        'detachInvalidate',
+        'fireEvent',
+        'focus',
+        'getDomRef',
+        'getFocusDomRef',
+        'getFocusDomRefAsync',
+        'getMetadata',
+        'getSlottedNodes',
+        'getStaticAreaItemDomRef',
+        'getUniqueDependencies',
+        'onAfterRendering',
+        'onBeforeRendering',
+        'onDefine',
+        'onEnterDOM',
+        'onExitDOM',
+        'onInvalidation',
+        'setConfirmedSettings',
+        'show',
+    ]),
+    __metadata("design:paramtypes", [ChangeDetectorRef,
+        ElementRef,
+        NgZone])
+], ViewSettingsDialogComponent);
+export { ViewSettingsDialogComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ViewSettingsDialogComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ui5-view-settings-dialog',
+                    template: `<ng-content></ng-content>`,
+                    exportAs: 'ui5ViewSettingsDialog',
+                    standalone: true,
+                    inputs: [
+                        'effectiveDir: effective-dir',
+                        'isUi5Element: is-ui-5-element',
+                        'sortDescending: sort-descending',
+                    ],
+                    outputs: [
+                        'beforeOpen: ui5BeforeOpen',
+                        'cancel: ui5Cancel',
+                        'confirm: ui5Confirm',
+                    ],
+                    providers: [],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/fiori/wizard/index.mjs

@@ -0,0 +1,61 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, ElementRef, NgZone, ChangeDetectorRef, } from '@angular/core';
+import { ProxyInputs, ProxyMethods, ProxyOutputs, } from '@ui5/webcomponents-ngx/utils';
+import '@ui5/webcomponents-fiori/dist/Wizard.js';
+import * as i0 from "@angular/core";
+// TS source file
+let WizardComponent = class WizardComponent {
+    constructor(c, elementRef, zone) {
+        this.c = c;
+        this.elementRef = elementRef;
+        this.zone = zone;
+        c.detach();
+    }
+    get element() {
+        return this.elementRef.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WizardComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: WizardComponent, isStandalone: true, selector: "ui5-wizard", inputs: { effectiveDir: ["effective-dir", "effectiveDir"], isUi5Element: ["is-ui-5-element", "isUi5Element"] }, outputs: { stepChange: "ui5StepChange" }, providers: [], exportAs: ["ui5Wizard"], ngImport: i0, template: `<ng-content></ng-content>`, isInline: true }); }
+};
+WizardComponent = __decorate([
+    ProxyInputs(['effectiveDir', 'isUi5Element']),
+    ProxyOutputs(['stepChange']),
+    ProxyMethods([
+        '_render',
+        'attachInvalidate',
+        'define',
+        'detachInvalidate',
+        'fireEvent',
+        'focus',
+        'getDomRef',
+        'getFocusDomRef',
+        'getFocusDomRefAsync',
+        'getMetadata',
+        'getSlottedNodes',
+        'getStaticAreaItemDomRef',
+        'getUniqueDependencies',
+        'onAfterRendering',
+        'onBeforeRendering',
+        'onDefine',
+        'onEnterDOM',
+        'onExitDOM',
+        'onInvalidation',
+    ]),
+    __metadata("design:paramtypes", [ChangeDetectorRef,
+        ElementRef,
+        NgZone])
+], WizardComponent);
+export { WizardComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WizardComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ui5-wizard',
+                    template: `<ng-content></ng-content>`,
+                    exportAs: 'ui5Wizard',
+                    standalone: true,
+                    inputs: ['effectiveDir: effective-dir', 'isUi5Element: is-ui-5-element'],
+                    outputs: ['stepChange: ui5StepChange'],
+                    providers: [],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/fiori/wizard-step/index.mjs

@@ -0,0 +1,79 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, ElementRef, NgZone, ChangeDetectorRef, } from '@angular/core';
+import { ProxyInputs, ProxyMethods, ProxyOutputs, } from '@ui5/webcomponents-ngx/utils';
+import '@ui5/webcomponents-fiori/dist/WizardStep.js';
+import * as i0 from "@angular/core";
+// TS source file
+let WizardStepComponent = class WizardStepComponent {
+    constructor(c, elementRef, zone) {
+        this.c = c;
+        this.elementRef = elementRef;
+        this.zone = zone;
+        c.detach();
+    }
+    get element() {
+        return this.elementRef.nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WizardStepComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: WizardStepComponent, isStandalone: true, selector: "ui5-wizard-step", inputs: { effectiveDir: ["effective-dir", "effectiveDir"], isUi5Element: ["is-ui-5-element", "isUi5Element"], branching: "branching", disabled: "disabled", icon: "icon", selected: "selected", subtitleText: ["subtitle-text", "subtitleText"], titleText: ["title-text", "titleText"] }, providers: [], exportAs: ["ui5WizardStep"], ngImport: i0, template: `<ng-content></ng-content>`, isInline: true }); }
+};
+WizardStepComponent = __decorate([
+    ProxyInputs([
+        'effectiveDir',
+        'isUi5Element',
+        'branching',
+        'disabled',
+        'icon',
+        'selected',
+        'subtitleText',
+        'titleText',
+    ]),
+    ProxyOutputs([]),
+    ProxyMethods([
+        '_render',
+        'attachInvalidate',
+        'define',
+        'detachInvalidate',
+        'fireEvent',
+        'focus',
+        'getDomRef',
+        'getFocusDomRef',
+        'getFocusDomRefAsync',
+        'getMetadata',
+        'getSlottedNodes',
+        'getStaticAreaItemDomRef',
+        'getUniqueDependencies',
+        'onAfterRendering',
+        'onBeforeRendering',
+        'onDefine',
+        'onEnterDOM',
+        'onExitDOM',
+        'onInvalidation',
+    ]),
+    __metadata("design:paramtypes", [ChangeDetectorRef,
+        ElementRef,
+        NgZone])
+], WizardStepComponent);
+export { WizardStepComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WizardStepComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ui5-wizard-step',
+                    template: `<ng-content></ng-content>`,
+                    exportAs: 'ui5WizardStep',
+                    standalone: true,
+                    inputs: [
+                        'effectiveDir: effective-dir',
+                        'isUi5Element: is-ui-5-element',
+                        'branching',
+                        'disabled',
+                        'icon',
+                        'selected',
+                        'subtitleText: subtitle-text',
+                        'titleText: title-text',
+                    ],
+                    outputs: [],
+                    providers: [],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/generic-cva/index.mjs

@@ -0,0 +1,42 @@
+import { Directive } from '@angular/core';
+import { BehaviorSubject, distinctUntilChanged, filter, map, Subject, switchMap, takeUntil, tap, } from 'rxjs';
+import fastDeepEqual from 'fast-deep-equal';
+import * as i0 from "@angular/core";
+class GenericControlValueAccessor {
+    constructor(host) {
+        this.host = host;
+        this._destroy$ = new Subject();
+        this._onChangeSet$ = new BehaviorSubject(false);
+        this.setDisabledState = () => {
+            // Placeholder
+        };
+        this.onChange$ = (val) => {
+            return this._onChangeSet$.pipe(filter(Boolean), tap(() => this.onChange(val)), map(() => val));
+        };
+        this.host.valueUpdatedNotifier$
+            .pipe(map(() => this.host.value), distinctUntilChanged(fastDeepEqual), tap((v) => (this._value = v)), switchMap(this.onChange$), takeUntil(this._destroy$))
+            .subscribe();
+        this.setDisabledState = this.host.setDisabledState;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+        this._onChangeSet$.next(true);
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    writeValue(val) {
+        this._value = val;
+        this.host.value = val;
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GenericControlValueAccessor, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: GenericControlValueAccessor, ngImport: i0 }); }
+}
+export { GenericControlValueAccessor };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GenericControlValueAccessor, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: undefined }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/i18n/i18n.module.mjs

@@ -0,0 +1,67 @@
+import { Inject, NgModule } from "@angular/core";
+import { setFetchDefaultLanguage, setLanguage } from "@ui5/webcomponents-base/dist/config/Language.js";
+import { I18nPipe } from "./i18n.pipe";
+import { I18nService } from "./i18n.service";
+import { I18N_NAMESPACE, I18N_ROOT_CONFIG } from "./i18n.tokens";
+import { resolveTranslationsProvider } from "./i18n.utils";
+import * as i0 from "@angular/core";
+let childIds = 0;
+class Ui5I18nModule {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    constructor(config) {
+        this.config = config;
+    }
+    static forRoot(config = {}) {
+        return {
+            ngModule: Ui5I18nModule,
+            providers: [
+                {
+                    provide: I18N_ROOT_CONFIG,
+                    useFactory: () => {
+                        if (config.language) {
+                            setLanguage(config.language);
+                        }
+                        if (config.fetchDefaultLanguage) {
+                            setFetchDefaultLanguage(config.fetchDefaultLanguage);
+                        }
+                        return config;
+                    }
+                },
+                {
+                    provide: I18N_NAMESPACE,
+                    useValue: config.bundle?.name || 'root_i18n'
+                },
+                resolveTranslationsProvider(config.bundle?.translations),
+                I18nService
+            ]
+        };
+    }
+    static forChild(config = {}) {
+        return {
+            ngModule: Ui5I18nModule,
+            providers: [
+                {
+                    provide: I18N_NAMESPACE,
+                    useValue: config?.name || ++childIds + '_i18n'
+                },
+                resolveTranslationsProvider(config?.translations),
+                I18nService
+            ]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Ui5I18nModule, deps: [{ token: I18N_ROOT_CONFIG }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: Ui5I18nModule, declarations: [I18nPipe], exports: [I18nPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Ui5I18nModule }); }
+}
+export { Ui5I18nModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Ui5I18nModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [I18nPipe],
+                    exports: [I18nPipe]
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [I18N_ROOT_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/i18n/i18n.pipe.mjs

@@ -0,0 +1,46 @@
+import { ChangeDetectorRef, Pipe } from "@angular/core";
+import { I18nService } from "./i18n.service";
+import { distinctUntilChanged, Subject, takeUntil } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "./i18n.service";
+class I18nPipe {
+    constructor(changeDetectorRef, i18nService) {
+        this.changeDetectorRef = changeDetectorRef;
+        this.i18nService = i18nService;
+        this._lastTranslationValue = '';
+        this._destroyed$ = new Subject();
+    }
+    transform(value, ...params) {
+        const paramsChanged = !this._lastValue || params.some((param, index) => param !== this._lastValueParams[index]);
+        if (value === this._lastValue && !paramsChanged) {
+            return this._lastTranslationValue;
+        }
+        this._lastValue = value;
+        this._lastValueParams = params;
+        if (this._subscription) {
+            this._subscription.unsubscribe();
+            this._subscription = undefined;
+        }
+        this._subscription = this.i18nService.getText(value, ...params)
+            .pipe(distinctUntilChanged(), takeUntil(this._destroyed$)).subscribe((text) => {
+            this._lastTranslationValue = text;
+            this.changeDetectorRef.markForCheck();
+        });
+        return this._lastTranslationValue;
+    }
+    ngOnDestroy() {
+        this._destroyed$.next();
+        this._destroyed$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: I18nPipe, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.I18nService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: I18nPipe, name: "ui5I18n", pure: false }); }
+}
+export { I18nPipe };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: I18nPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'ui5I18n',
+                    pure: false
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.I18nService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaTE4bi5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy91aTUtYW5ndWxhci9pMThuL2kxOG4ucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsaUJBQWlCLEVBQWEsSUFBSSxFQUFnQixNQUFNLGVBQWUsQ0FBQztBQUNoRixPQUFPLEVBQUMsV0FBVyxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFDM0MsT0FBTyxFQUFDLG9CQUFvQixFQUFFLE9BQU8sRUFBZ0IsU0FBUyxFQUFDLE1BQU0sTUFBTSxDQUFDOzs7QUFFNUUsTUFJYSxRQUFRO0lBT25CLFlBQW9CLGlCQUFvQyxFQUNwQyxXQUF3QjtRQUR4QixzQkFBaUIsR0FBakIsaUJBQWlCLENBQW1CO1FBQ3BDLGdCQUFXLEdBQVgsV0FBVyxDQUFhO1FBUHBDLDBCQUFxQixHQUFHLEVBQUUsQ0FBQztRQUUzQixnQkFBVyxHQUFHLElBQUksT0FBTyxFQUFRLENBQUM7SUFNMUMsQ0FBQztJQUVELFNBQVMsQ0FBQyxLQUFhLEVBQUUsR0FBRyxNQUFhO1FBQ3ZDLE1BQU0sYUFBYSxHQUFHLENBQUMsSUFBSSxDQUFDLFVBQVUsSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsS0FBSyxFQUFFLEtBQUssRUFBRSxFQUFFLENBQUMsS0FBSyxLQUFLLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1FBQ2hILElBQUksS0FBSyxLQUFLLElBQUksQ0FBQyxVQUFVLElBQUksQ0FBQyxhQUFhLEVBQUU7WUFDL0MsT0FBTyxJQUFJLENBQUMscUJBQXFCLENBQUM7U0FDbkM7UUFDRCxJQUFJLENBQUMsVUFBVSxHQUFHLEtBQUssQ0FBQztRQUN4QixJQUFJLENBQUMsZ0JBQWdCLEdBQUcsTUFBTSxDQUFDO1FBQy9CLElBQUksSUFBSSxDQUFDLGFBQWEsRUFBRTtZQUN0QixJQUFJLENBQUMsYUFBYSxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQ2pDLElBQUksQ0FBQyxhQUFhLEdBQUcsU0FBUyxDQUFDO1NBQ2hDO1FBQ0QsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsR0FBRyxNQUFNLENBQUM7YUFDNUQsSUFBSSxDQUNILG9CQUFvQixFQUFFLEVBQ3RCLFNBQVMsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQzVCLENBQUMsU0FBUyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUU7WUFDbkIsSUFBSSxDQUFDLHFCQUFxQixHQUFHLElBQUksQ0FBQztZQUNsQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsWUFBWSxFQUFFLENBQUM7UUFDeEMsQ0FBQyxDQUFDLENBQUM7UUFDTCxPQUFPLElBQUksQ0FBQyxxQkFBcUIsQ0FBQztJQUNwQyxDQUFDO0lBRUQsV0FBVztRQUNULElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDeEIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUM5QixDQUFDOzhHQXBDVSxRQUFROzRHQUFSLFFBQVE7O1NBQVIsUUFBUTsyRkFBUixRQUFRO2tCQUpwQixJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxTQUFTO29CQUNmLElBQUksRUFBRSxLQUFLO2lCQUNaIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDaGFuZ2VEZXRlY3RvclJlZiwgT25EZXN0cm95LCBQaXBlLCBQaXBlVHJhbnNmb3JtfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHtJMThuU2VydmljZX0gZnJvbSBcIi4vaTE4bi5zZXJ2aWNlXCI7XG5pbXBvcnQge2Rpc3RpbmN0VW50aWxDaGFuZ2VkLCBTdWJqZWN0LCBTdWJzY3JpcHRpb24sIHRha2VVbnRpbH0gZnJvbSBcInJ4anNcIjtcblxuQFBpcGUoe1xuICBuYW1lOiAndWk1STE4bicsXG4gIHB1cmU6IGZhbHNlXG59KVxuZXhwb3J0IGNsYXNzIEkxOG5QaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSwgT25EZXN0cm95IHtcbiAgcHJpdmF0ZSBfbGFzdFRyYW5zbGF0aW9uVmFsdWUgPSAnJztcbiAgcHJpdmF0ZSBfc3Vic2NyaXB0aW9uPzogU3Vic2NyaXB0aW9uO1xuICBwcml2YXRlIF9kZXN0cm95ZWQkID0gbmV3IFN1YmplY3Q8dm9pZD4oKTtcbiAgcHJpdmF0ZSBfbGFzdFZhbHVlITogc3RyaW5nO1xuICBwcml2YXRlIF9sYXN0VmFsdWVQYXJhbXMhOiBzdHJpbmdbXTtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGNoYW5nZURldGVjdG9yUmVmOiBDaGFuZ2VEZXRlY3RvclJlZixcbiAgICAgICAgICAgICAgcHJpdmF0ZSBpMThuU2VydmljZTogSTE4blNlcnZpY2UpIHtcbiAgfVxuXG4gIHRyYW5zZm9ybSh2YWx1ZTogc3RyaW5nLCAuLi5wYXJhbXM6IGFueVtdKTogc3RyaW5nIHtcbiAgICBjb25zdCBwYXJhbXNDaGFuZ2VkID0gIXRoaXMuX2xhc3RWYWx1ZSB8fCBwYXJhbXMuc29tZSgocGFyYW0sIGluZGV4KSA9PiBwYXJhbSAhPT0gdGhpcy5fbGFzdFZhbHVlUGFyYW1zW2luZGV4XSk7XG4gICAgaWYgKHZhbHVlID09PSB0aGlzLl9sYXN0VmFsdWUgJiYgIXBhcmFtc0NoYW5nZWQpIHtcbiAgICAgIHJldHVybiB0aGlzLl9sYXN0VHJhbnNsYXRpb25WYWx1ZTtcbiAgICB9XG4gICAgdGhpcy5fbGFzdFZhbHVlID0gdmFsdWU7XG4gICAgdGhpcy5fbGFzdFZhbHVlUGFyYW1zID0gcGFyYW1zO1xuICAgIGlmICh0aGlzLl9zdWJzY3JpcHRpb24pIHtcbiAgICAgIHRoaXMuX3N1YnNjcmlwdGlvbi51bnN1YnNjcmliZSgpO1xuICAgICAgdGhpcy5fc3Vic2NyaXB0aW9uID0gdW5kZWZpbmVkO1xuICAgIH1cbiAgICB0aGlzLl9zdWJzY3JpcHRpb24gPSB0aGlzLmkxOG5TZXJ2aWNlLmdldFRleHQodmFsdWUsIC4uLnBhcmFtcylcbiAgICAgIC5waXBlKFxuICAgICAgICBkaXN0aW5jdFVudGlsQ2hhbmdlZCgpLFxuICAgICAgICB0YWtlVW50aWwodGhpcy5fZGVzdHJveWVkJClcbiAgICAgICkuc3Vic2NyaWJlKCh0ZXh0KSA9PiB7XG4gICAgICAgIHRoaXMuX2xhc3RUcmFuc2xhdGlvblZhbHVlID0gdGV4dDtcbiAgICAgICAgdGhpcy5jaGFuZ2VEZXRlY3RvclJlZi5tYXJrRm9yQ2hlY2soKTtcbiAgICAgIH0pO1xuICAgIHJldHVybiB0aGlzLl9sYXN0VHJhbnNsYXRpb25WYWx1ZTtcbiAgfVxuXG4gIG5nT25EZXN0cm95KCk6IHZvaWQge1xuICAgIHRoaXMuX2Rlc3Ryb3llZCQubmV4dCgpO1xuICAgIHRoaXMuX2Rlc3Ryb3llZCQuY29tcGxldGUoKTtcbiAgfVxufVxuIl19

package/esm2022/i18n/i18n.service.mjs

@@ -0,0 +1,76 @@
+import { Inject, inject, Injectable } from "@angular/core";
+import { getI18nBundle, registerI18nLoader } from "@ui5/webcomponents-base/dist/i18nBundle.js";
+import parseProperties from "@ui5/webcomponents-base/dist/PropertiesFileFormat.js";
+import { getLanguage, setLanguage } from "@ui5/webcomponents-base/dist/config/Language.js";
+import { BehaviorSubject, filter, first, firstValueFrom, from, isObservable, map, of, switchMap, tap } from "rxjs";
+import { I18N_NAMESPACE, I18N_ROOT_CONFIG, I18N_TRANSLATIONS } from "./i18n.tokens";
+import * as i0 from "@angular/core";
+class I18nService {
+    constructor(config, namespace, bundles = {}) {
+        this.config = config;
+        this.namespace = namespace;
+        this.bundles = bundles;
+        this.parent = inject(I18nService, { skipSelf: true, optional: true });
+        this.currentLanguage$ = new BehaviorSubject(getLanguage() || this.config.language);
+        this.loadedLanguages$ = new BehaviorSubject([]);
+        Object.keys(bundles).forEach((lang) => {
+            registerI18nLoader(this.namespace, lang, async (localeId) => {
+                const val = this.bundles[localeId];
+                const result = isObservable(val) ? await firstValueFrom(val) : await val;
+                setTimeout(() => {
+                    this.loadedLanguages$.next([
+                        ...new Set([...this.loadedLanguages$.value, localeId]).values()
+                    ]);
+                });
+                if (typeof result === 'string') {
+                    return parseProperties(result);
+                }
+                return result;
+            });
+        });
+        this.i18nBundle$ = from(getI18nBundle(this.namespace));
+    }
+    currentLanguage() {
+        if (this.parent) {
+            return this.parent.currentLanguage();
+        }
+        return this.currentLanguage$.value;
+    }
+    currentLanguageEvent() {
+        if (this.parent) {
+            return this.parent.currentLanguageEvent();
+        }
+        return this.currentLanguage$;
+    }
+    setLanguage(language) {
+        if (this.parent) {
+            return this.parent.setLanguage(language);
+        }
+        setLanguage(language);
+        this.loadedLanguages$.pipe(filter(langs => langs.includes(language)), first(), tap(() => this.currentLanguage$.next(language))).subscribe();
+    }
+    getText(key, ...placeholders) {
+        return this.currentLanguageEvent().pipe(switchMap(() => this.i18nBundle$), map((bundle) => bundle.getText({ key, defaultText: key }, ...placeholders)), switchMap((text) => {
+            if (text === key && this.parent) {
+                return this.parent.getText(key, ...placeholders);
+            }
+            return of(text);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: I18nService, deps: [{ token: I18N_ROOT_CONFIG }, { token: I18N_NAMESPACE }, { token: I18N_TRANSLATIONS }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: I18nService }); }
+}
+export { I18nService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: I18nService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [I18N_ROOT_CONFIG]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [I18N_NAMESPACE]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [I18N_TRANSLATIONS]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/icons/icons.module.mjs

@@ -0,0 +1,44 @@
+import { isDevMode, NgModule } from "@angular/core";
+import { IconsProvider } from "./icons.provider";
+import { Ui5AngularSelectedIconsToLoad } from "./icons.tokens";
+import * as i0 from "@angular/core";
+import * as i1 from "./icons.provider";
+const iconPackageNameToFileMap = {
+    'sap-icons': () => import('@ui5/webcomponents-icons/dist/AllIcons').then(() => 'sap-icons'),
+    'tnt-icons': () => import('@ui5/webcomponents-icons-tnt/dist/AllIcons').then(() => 'tnt-icons'),
+    'business-suite-icons': () => import('@ui5/webcomponents-icons-business-suite/dist/AllIcons').then(() => 'business-suite-icons')
+};
+class Ui5WebcomponentsIconsModule {
+    constructor(iconsProvider) {
+        this.iconsProvider = iconsProvider;
+        if (isDevMode()) {
+            console.log('Ui5WebcomponentsIconsModule loaded', iconsProvider);
+        }
+    }
+    static forRoot(iconsToLoad) {
+        return {
+            ngModule: Ui5WebcomponentsIconsModule,
+            providers: [
+                ...iconsToLoad.map(icon => ({
+                    provide: Ui5AngularSelectedIconsToLoad,
+                    useValue: iconPackageNameToFileMap[icon],
+                    multi: true
+                })),
+                IconsProvider
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Ui5WebcomponentsIconsModule, deps: [{ token: i1.IconsProvider }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: Ui5WebcomponentsIconsModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Ui5WebcomponentsIconsModule }); }
+}
+export { Ui5WebcomponentsIconsModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Ui5WebcomponentsIconsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [],
+                    exports: [],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.IconsProvider }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/icons/icons.provider.mjs

@@ -0,0 +1,23 @@
+import { Inject, Injectable, isDevMode } from "@angular/core";
+import { Ui5AngularSelectedIconsToLoad } from "./icons.tokens";
+import * as i0 from "@angular/core";
+class IconsProvider {
+    constructor(iconsToLoad) {
+        this.iconsToLoad = iconsToLoad;
+        Promise.all(this.iconsToLoad.map(l => l())).then((r) => {
+            if (isDevMode()) {
+                console.log('Icons loaded', r);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: IconsProvider, deps: [{ token: Ui5AngularSelectedIconsToLoad }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: IconsProvider }); }
+}
+export { IconsProvider };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: IconsProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: Array, decorators: [{
+                    type: Inject,
+                    args: [Ui5AngularSelectedIconsToLoad]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWNvbnMucHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3VpNS1hbmd1bGFyL2ljb25zL2ljb25zLnByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxNQUFNLEVBQUUsVUFBVSxFQUFFLFNBQVMsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUM1RCxPQUFPLEVBQUMsNkJBQTZCLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQzs7QUFFN0QsTUFDYSxhQUFhO0lBQ3hCLFlBQTJELFdBQXNDO1FBQXRDLGdCQUFXLEdBQVgsV0FBVyxDQUEyQjtRQUMvRixPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFO1lBQ3JELElBQUksU0FBUyxFQUFFLEVBQUU7Z0JBQ2YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxjQUFjLEVBQUUsQ0FBQyxDQUFDLENBQUM7YUFDaEM7UUFDSCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7OEdBUFUsYUFBYSxrQkFDSiw2QkFBNkI7a0hBRHRDLGFBQWE7O1NBQWIsYUFBYTsyRkFBYixhQUFhO2tCQUR6QixVQUFVOzswQkFFSSxNQUFNOzJCQUFDLDZCQUE2QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5qZWN0LCBJbmplY3RhYmxlLCBpc0Rldk1vZGV9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQge1VpNUFuZ3VsYXJTZWxlY3RlZEljb25zVG9Mb2FkfSBmcm9tIFwiLi9pY29ucy50b2tlbnNcIjtcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIEljb25zUHJvdmlkZXIge1xuICBjb25zdHJ1Y3RvcihASW5qZWN0KFVpNUFuZ3VsYXJTZWxlY3RlZEljb25zVG9Mb2FkKSBwcml2YXRlIGljb25zVG9Mb2FkOiBBcnJheTwoKSA9PiBQcm9taXNlPGFueT4+KSB7XG4gICAgUHJvbWlzZS5hbGwodGhpcy5pY29uc1RvTG9hZC5tYXAobCA9PiBsKCkpKS50aGVuKChyKSA9PiB7XG4gICAgICBpZiAoaXNEZXZNb2RlKCkpIHtcbiAgICAgICAgY29uc29sZS5sb2coJ0ljb25zIGxvYWRlZCcsIHIpO1xuICAgICAgfVxuICAgIH0pO1xuICB9XG59XG4iXX0=