@wallfree-dev/angular-ngrx 0.0.59-beta.1

package/README.md

@@ -0,0 +1,60 @@
+# @wallfree-dev/angular-ngrx
+
+[![npm](https://img.shields.io/npm/v/@wallfree-dev/angular-ngrx.svg?colorB=brightgreen)](https://www.npmjs.com/package/@wallfree-dev/ngrx)
+[![build](https://img.shields.io/travis/airgap-it/angular-ngrx.svg)](https://travis-ci.org/airgap-it/angular-ngrx/)
+[![codecov](https://img.shields.io/codecov/c/gh/airgap-it/angular-ngrx.svg)](https://codecov.io/gh/airgap-it/angular-ngrx/)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+
+`@wallfree-dev/angular-ngrx` extends `@wallfree-dev/angular-core` providing [NgRx](https://ngrx.io/) support for its components.
+
+## Requirements
+
+Please check `peerDependencies` in `package.json` to see what dependencies are required for this library.
+
+## Install
+
+```
+$ npm install --save @wallfree-dev/angular-ngrx
+```
+
+## Development
+
+### Requirements
+
+Make sure you have statisfied the following requirements before building or testing the project:
+
+```
+npm >= 6
+```
+
+### Build
+
+Before building the library make sure you have installed the root project dependencies. If not, run:
+
+```
+$ cd ../..
+$ npm install
+$ cd packages/ngrx
+```
+
+To build the `ngrx` library run:
+
+```
+$ npm run build
+```
+
+### Run Tests
+
+Before running the tests make sure you have installed the root project dependencies. If not, run:
+
+```
+$ cd ../..
+$ npm install
+$ cd packages/ngrx
+```
+
+To run tests for the `ngrx` library run:
+
+```
+$ npm run test
+```

package/esm2022/lib/airgap-angular-ngrx.module.mjs

@@ -0,0 +1,23 @@
+import { NgModule } from '@angular/core';
+import { StoreModule } from '@ngrx/store';
+import { ComponentsModule } from './components/components.module';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+export class AirGapAngularNgRxModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AirGapAngularNgRxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: AirGapAngularNgRxModule, imports: [i1.StoreFeatureModule, ComponentsModule], exports: [ComponentsModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AirGapAngularNgRxModule, imports: [StoreModule.forFeature('shared', {}),
+            ComponentsModule, ComponentsModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AirGapAngularNgRxModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [
+                        StoreModule.forFeature('shared', {}),
+                        ComponentsModule
+                    ],
+                    exports: [ComponentsModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWlyZ2FwLWFuZ3VsYXItbmdyeC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2FpcmdhcC1hbmd1bGFyLW5ncngubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFDeEMsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUN6QyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQTs7O0FBVWpFLE1BQU0sT0FBTyx1QkFBdUI7K0dBQXZCLHVCQUF1QjtnSEFBdkIsdUJBQXVCLG1DQUpoQyxnQkFBZ0IsYUFFUixnQkFBZ0I7Z0hBRWYsdUJBQXVCLFlBTGhDLFdBQVcsQ0FBQyxVQUFVLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQztZQUNwQyxnQkFBZ0IsRUFFUixnQkFBZ0I7OzRGQUVmLHVCQUF1QjtrQkFSbkMsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsRUFBRTtvQkFDaEIsT0FBTyxFQUFFO3dCQUNQLFdBQVcsQ0FBQyxVQUFVLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQzt3QkFDcEMsZ0JBQWdCO3FCQUNqQjtvQkFDRCxPQUFPLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQztpQkFDNUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5pbXBvcnQgeyBTdG9yZU1vZHVsZSB9IGZyb20gJ0BuZ3J4L3N0b3JlJ1xuaW1wb3J0IHsgQ29tcG9uZW50c01vZHVsZSB9IGZyb20gJy4vY29tcG9uZW50cy9jb21wb25lbnRzLm1vZHVsZSdcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbXSxcbiAgaW1wb3J0czogW1xuICAgIFN0b3JlTW9kdWxlLmZvckZlYXR1cmUoJ3NoYXJlZCcsIHt9KSxcbiAgICBDb21wb25lbnRzTW9kdWxlXG4gIF0sXG4gIGV4cG9ydHM6IFtDb21wb25lbnRzTW9kdWxlXVxufSlcbmV4cG9ydCBjbGFzcyBBaXJHYXBBbmd1bGFyTmdSeE1vZHVsZSB7fVxuIl19

package/esm2022/lib/base/base-ngrx.facade.mjs

@@ -0,0 +1,36 @@
+import { BaseFacade, UIActionStatus } from '@wallfree-dev/angular-core';
+export class BaseNgRxFacade extends BaseFacade {
+    constructor(store, uiEventService) {
+        super();
+        this.store = store;
+        this.uiEventService = uiEventService;
+    }
+    async showOrHideToast(toast) {
+        if (this.uiEventService === undefined) {
+            return;
+        }
+        // TODO: Move error sentries to common components and catch toast errors
+        this.toastElement?.dismiss();
+        if (toast?.status === UIActionStatus.PENDING) {
+            const defaultToastOptions = {
+                duration: 3000,
+                position: 'bottom'
+            };
+            this.toastElement = await this.uiEventService.getTranslatedToast({ ...defaultToastOptions, ...this.getToastData(toast.value) });
+            this.toastElement.present();
+            return this.toastElement.onWillDismiss().then(() => {
+                this.onToastDismissed(toast);
+            });
+        }
+        else {
+            this.toastElement = undefined;
+        }
+    }
+    onToastDismissed(_toast) {
+        throw new Error('`onToastDismissed` not implemented');
+    }
+    getToastData(_toast) {
+        throw new Error('`getToastData` not implemented');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/components.module.mjs

@@ -0,0 +1,21 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { IonicModule } from '@ionic/angular';
+import { TranslateModule } from '@ngx-translate/core';
+import { QRCodeModule } from 'angularx-qrcode';
+import * as i0 from "@angular/core";
+export class ComponentsModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ComponentsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: ComponentsModule, imports: [CommonModule, IonicModule, TranslateModule, QRCodeModule, FormsModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ComponentsModule, imports: [CommonModule, IonicModule, TranslateModule, QRCodeModule, FormsModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ComponentsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [CommonModule, IonicModule, TranslateModule, QRCodeModule, FormsModule],
+                    exports: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50cy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvY29tcG9uZW50cy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFBO0FBQzlDLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFDeEMsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFBO0FBQzVDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQTtBQUM1QyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0scUJBQXFCLENBQUE7QUFDckQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFBOztBQU85QyxNQUFNLE9BQU8sZ0JBQWdCOytHQUFoQixnQkFBZ0I7Z0hBQWhCLGdCQUFnQixZQUhqQixZQUFZLEVBQUUsV0FBVyxFQUFFLGVBQWUsRUFBRSxZQUFZLEVBQUUsV0FBVztnSEFHcEUsZ0JBQWdCLFlBSGpCLFlBQVksRUFBRSxXQUFXLEVBQUUsZUFBZSxFQUFFLFlBQVksRUFBRSxXQUFXOzs0RkFHcEUsZ0JBQWdCO2tCQUw1QixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxFQUFFO29CQUNoQixPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsV0FBVyxFQUFFLGVBQWUsRUFBRSxZQUFZLEVBQUUsV0FBVyxDQUFDO29CQUNoRixPQUFPLEVBQUUsRUFBRTtpQkFDWiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbidcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSdcbmltcG9ydCB7IEZvcm1zTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnXG5pbXBvcnQgeyBJb25pY01vZHVsZSB9IGZyb20gJ0Bpb25pYy9hbmd1bGFyJ1xuaW1wb3J0IHsgVHJhbnNsYXRlTW9kdWxlIH0gZnJvbSAnQG5neC10cmFuc2xhdGUvY29yZSdcbmltcG9ydCB7IFFSQ29kZU1vZHVsZSB9IGZyb20gJ2FuZ3VsYXJ4LXFyY29kZSdcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbXSxcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgSW9uaWNNb2R1bGUsIFRyYW5zbGF0ZU1vZHVsZSwgUVJDb2RlTW9kdWxlLCBGb3Jtc01vZHVsZV0sXG4gIGV4cG9ydHM6IFtdXG59KVxuZXhwb3J0IGNsYXNzIENvbXBvbmVudHNNb2R1bGUge31cbiJdfQ==

package/esm2022/lib/components/currency-symbol/currency-symbol.facade.mjs

@@ -0,0 +1,59 @@
+import { FilesystemService, ProtocolService } from '@wallfree-dev/angular-core';
+import { Injectable } from '@angular/core';
+import { BaseNgRxFacade } from '../../base/base-ngrx.facade';
+import { CurrencySymbolStore } from './currency-symbol.store';
+import * as i0 from "@angular/core";
+import * as i1 from "./currency-symbol.store";
+import * as i2 from "@wallfree-dev/angular-core";
+export class CurrencySymbolNgRxFacade extends BaseNgRxFacade {
+    constructor(store, protocolService) {
+        super(store);
+        this.protocolService = protocolService;
+        this.symbolSrc$ = this.store.select((state) => state.src);
+    }
+    initWithSymbol(symbol, protocolIdentifier) {
+        this.getSymbolInputs(symbol, protocolIdentifier)
+            .then((symbolInputs) => this.store.setInitialSrc(symbolInputs))
+            .catch(console.error);
+    }
+    onSymbolChanged(symbol, protocolIdentifier) {
+        this.getSymbolInputs(symbol, protocolIdentifier)
+            .then((symbolInputs) => this.store.setInitialSrc(symbolInputs))
+            .catch(console.error);
+    }
+    onError(_symbol, _protocolIdentifier, _src) {
+        this.store.onError$();
+    }
+    async getSymbolInputs(symbol, protocolIdentifier) {
+        let assetSymbol;
+        try {
+            const protocol = await this.protocolService.getProtocol(protocolIdentifier);
+            const [protocolSymbol, protocolAssetSymbol] = await Promise.all([
+                protocol.getSymbol(),
+                protocol.getAssetSymbol()
+            ]);
+            assetSymbol = protocolSymbol.toLowerCase() === symbol.toLowerCase() ? protocolAssetSymbol : undefined;
+        }
+        catch (e) {
+            console.warn(e);
+        }
+        assetSymbol = assetSymbol ?? symbol;
+        const symbolInput = assetSymbol ? { value: assetSymbol, caseSensitive: false } : undefined;
+        const protocolIdentifierInput = protocolIdentifier
+            ? { value: protocolIdentifier, caseSensitive: true }
+            : undefined;
+        const symbolInputs = protocolIdentifier && this.protocolService.isKnownProtocolSymbol(protocolIdentifier)
+            ? [symbolInput, protocolIdentifierInput]
+            : [protocolIdentifierInput, symbolInput];
+        return symbolInputs.filter((symbolInputOrUndefined) => symbolInputOrUndefined !== undefined);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrencySymbolNgRxFacade, deps: [{ token: i1.CurrencySymbolStore }, { token: i2.ProtocolService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrencySymbolNgRxFacade }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrencySymbolNgRxFacade, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.CurrencySymbolStore }, { type: i2.ProtocolService }] });
+export const currencySymbolNgRxFacade = (injector) => {
+    return new CurrencySymbolNgRxFacade(new CurrencySymbolStore(injector.get(FilesystemService)), injector.get(ProtocolService));
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/currency-symbol/currency-symbol.store.mjs

@@ -0,0 +1,148 @@
+import { DEFAULT_CURRENCY_SYMBOL_URL } from '@wallfree-dev/angular-core';
+import { Injectable } from '@angular/core';
+import { ComponentStore, tapResponse } from '@ngrx/component-store';
+import { Observable } from 'rxjs';
+import { map, repeat, switchMap, withLatestFrom } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@wallfree-dev/angular-core";
+const initialStore = {
+    src: DEFAULT_CURRENCY_SYMBOL_URL,
+    input: undefined,
+    fallbackInput: undefined,
+    inputs: []
+};
+export class CurrencySymbolStore extends ComponentStore {
+    constructor(filesystemService) {
+        super(initialStore);
+        this.filesystemService = filesystemService;
+        this.onError$ = this.effect((trigger$) => {
+            return trigger$.pipe(withLatestFrom(this.state$), switchMap(([, state]) => {
+                return this.loadFallbackImage(state).pipe(map((value) => {
+                    if (value.kind === 'lazy' && value.url === undefined) {
+                        return !state.fallbackInput || value.symbolInput === state.fallbackInput
+                            ? { kind: 'default' }
+                            : { kind: 'asset', symbolInput: state.fallbackInput, extension: 'svg' }; // try again with fallback symbol
+                    }
+                    else {
+                        return value;
+                    }
+                }), tapResponse((value) => this.setSrc(value), () => this.setSrc({ kind: 'default' })));
+            }), repeat());
+        });
+        this.setInitialSrc = this.updater((state, inputs) => {
+            const input = inputs[0];
+            const fallbackInput = inputs[1];
+            return {
+                ...state,
+                src: input ? this.getSymbolAssetURL(input, 'svg') /* use .svg by default */ : state.src,
+                fallbackType: input ? { kind: 'asset', symbolInput: input, extension: 'png' } /* use .png as a fallback */ : state.fallbackType,
+                input,
+                fallbackInput,
+                inputs
+            };
+        });
+        this.setSrc = this.updater((state, value) => {
+            switch (value.kind) {
+                case 'default':
+                    return {
+                        ...state,
+                        src: DEFAULT_CURRENCY_SYMBOL_URL,
+                        input: undefined,
+                        fallbackInput: undefined
+                    };
+                case 'asset':
+                    const { current: assetCurrent, fallback: assetFallback } = this.getNextInputs(state, value.symbolInput);
+                    return {
+                        ...state,
+                        src: this.getSymbolAssetURL(value.symbolInput, value.extension),
+                        fallbackType: value.extension === 'svg'
+                            ? { kind: 'asset', symbolInput: value.symbolInput, extension: 'png' } /* use .png as a fallback */
+                            : { kind: 'isolated', symbolInput: value.symbolInput } /* try loading external isolated image as a fallback */,
+                        input: assetCurrent,
+                        fallbackInput: assetFallback
+                    };
+                case 'isolated':
+                    const { current: isolatedCurrent, fallback: isolatedFallback } = this.getNextInputs(state, value.symbolInput);
+                    return {
+                        ...state,
+                        src: value.url ?? '',
+                        fallbackType: !state.fallbackInput || value.symbolInput === state.fallbackInput
+                            ? { kind: 'lazy', symbolInput: value.symbolInput } /* try loading external image as a fallback */
+                            : { kind: 'asset', symbolInput: state.fallbackInput, extension: 'svg' } /* try again with fallback symbol */,
+                        input: isolatedCurrent,
+                        fallbackInput: isolatedFallback
+                    };
+                case 'lazy':
+                    const { current: lazyCurrent, fallback: lazyFallback } = this.getNextInputs(state, value.symbolInput);
+                    return {
+                        ...state,
+                        src: value.url ?? '',
+                        fallbackType: !state.fallbackInput || value.symbolInput === state.fallbackInput
+                            ? { kind: 'default' }
+                            : { kind: 'asset', symbolInput: state.fallbackInput, extension: 'svg' } /* try again with fallback symbol */,
+                        input: lazyCurrent,
+                        fallbackInput: lazyFallback
+                    };
+                default:
+                    return state;
+            }
+        });
+    }
+    getNextInputs(state, input) {
+        if (!input) {
+            return {};
+        }
+        const index = state.inputs.indexOf(input);
+        return index > -1 ? { current: state.inputs[index], fallback: state.inputs[index + 1] } : {};
+    }
+    loadFallbackImage(state) {
+        return new Observable((subscriber) => {
+            new Promise(async (resolve, reject) => {
+                try {
+                    subscriber.next({ kind: 'default' });
+                    if (state.fallbackType?.kind === 'asset') {
+                        subscriber.next({ kind: 'asset', symbolInput: state.fallbackType.symbolInput, extension: state.fallbackType.extension });
+                    }
+                    else if (state.fallbackType?.kind === 'isolated') {
+                        const imageURI = await this.loadIsolatedImage(state.fallbackType.symbolInput);
+                        subscriber.next({ kind: 'isolated', symbolInput: state.fallbackType.symbolInput, url: imageURI });
+                    }
+                    else if (state.fallbackType?.kind === 'lazy') {
+                        // try loading external image
+                        const imageURI = await this.loadLazyImage(state.fallbackType.symbolInput);
+                        subscriber.next({ kind: 'lazy', symbolInput: state.fallbackType.symbolInput, url: imageURI });
+                    }
+                    else {
+                        // no image was found for the symbol, use the generic image
+                        subscriber.next({ kind: 'default' });
+                    }
+                    resolve();
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }).finally(() => {
+                subscriber.complete();
+            });
+        });
+    }
+    async loadIsolatedImage(symbolInput) {
+        return this.filesystemService.readIsolatedSymbol(symbolInput.caseSensitive ? symbolInput.value : symbolInput.value.toLocaleLowerCase());
+    }
+    async loadLazyImage(symbolInput) {
+        const imagePath = this.getSymbolImagePath(symbolInput);
+        return this.filesystemService.readLazyImage(imagePath);
+    }
+    getSymbolAssetURL(symbolInput, extension) {
+        return `./assets/symbols/${symbolInput.caseSensitive ? symbolInput.value : symbolInput.value.toLowerCase()}.${extension}`;
+    }
+    getSymbolImagePath(symbolInput) {
+        return `/images/symbols/${symbolInput.caseSensitive ? symbolInput.value : symbolInput.value.toLowerCase()}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrencySymbolStore, deps: [{ token: i1.FilesystemService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrencySymbolStore }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrencySymbolStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.FilesystemService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"currency-symbol.store.js","sourceRoot":"","sources":["../../../../../src/lib/components/currency-symbol/currency-symbol.store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAA+C,MAAM,4BAA4B,CAAA;AACrH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAE,UAAU,EAAc,MAAM,MAAM,CAAA;AAC7C,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;;;AAIvE,MAAM,YAAY,GAAwB;IACxC,GAAG,EAAE,2BAA2B;IAEhC,KAAK,EAAE,SAAS;IAChB,aAAa,EAAE,SAAS;IACxB,MAAM,EAAE,EAAE;CACX,CAAA;AAGD,MAAM,OAAO,mBAAoB,SAAQ,cAAmC;IAC1E,YAA6B,iBAAoC;QAC/D,KAAK,CAAC,YAAY,CAAC,CAAA;QADQ,sBAAiB,GAAjB,iBAAiB,CAAmB;QAIjD,aAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,QAA0B,EAAE,EAAE;YACpE,OAAO,QAAQ,CAAC,IAAI,CAClB,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,EAC3B,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,CAA8B,EAAE,EAAE;gBACnD,OAAO,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,IAAI,CACvC,GAAG,CAAC,CAAC,KAAkB,EAAE,EAAE;oBACzB,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;wBACrD,OAAO,CAAC,KAAK,CAAC,aAAa,IAAI,KAAK,CAAC,WAAW,KAAK,KAAK,CAAC,aAAa;4BACtE,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE;4BACrB,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,CAAC,aAAa,EAAE,SAAS,EAAE,KAAK,EAAE,CAAA,CAAC,iCAAiC;oBAC7G,CAAC;yBAAM,CAAC;wBACN,OAAO,KAAK,CAAA;oBACd,CAAC;gBACH,CAAC,CAAC,EACF,WAAW,CACT,CAAC,KAAkB,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAC1C,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CACvC,CACF,CAAA;YACH,CAAC,CAAC,EACF,MAAM,EAAE,CACT,CAAA;QACH,CAAC,CAAC,CAAA;QAEc,kBAAa,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,KAA0B,EAAE,MAAqB,EAAE,EAAE;YACjG,MAAM,KAAK,GAA4B,MAAM,CAAC,CAAC,CAAC,CAAA;YAChD,MAAM,aAAa,GAA4B,MAAM,CAAC,CAAC,CAAC,CAAA;YAExD,OAAO;gBACL,GAAG,KAAK;gBACR,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG;gBACvF,YAAY,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,4BAA4B,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY;gBAE/H,KAAK;gBACL,aAAa;gBACb,MAAM;aACP,CAAA;QACH,CAAC,CAAC,CAAA;QAEe,WAAM,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,KAA0B,EAAE,KAAkB,EAAE,EAAE;YACxF,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;gBACnB,KAAK,SAAS;oBACZ,OAAO;wBACL,GAAG,KAAK;wBACR,GAAG,EAAE,2BAA2B;wBAEhC,KAAK,EAAE,SAAS;wBAChB,aAAa,EAAE,SAAS;qBACzB,CAAA;gBACH,KAAK,OAAO;oBACV,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;oBAEvG,OAAO;wBACL,GAAG,KAAK;wBACR,GAAG,EAAE,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC;wBAC/D,YAAY,EACV,KAAK,CAAC,SAAS,KAAK,KAAK;4BACvB,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,4BAA4B;4BAClG,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC,uDAAuD;wBAElH,KAAK,EAAE,YAAY;wBACnB,aAAa,EAAE,aAAa;qBAC7B,CAAA;gBACH,KAAK,UAAU;oBACb,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;oBAE7G,OAAO;wBACL,GAAG,KAAK;wBACR,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI,EAAE;wBACpB,YAAY,EACV,CAAC,KAAK,CAAC,aAAa,IAAI,KAAK,CAAC,WAAW,KAAK,KAAK,CAAC,aAAa;4BAC/D,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC,8CAA8C;4BACjG,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,CAAC,aAAa,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,oCAAoC;wBAEhH,KAAK,EAAE,eAAe;wBACtB,aAAa,EAAE,gBAAgB;qBAChC,CAAA;gBACH,KAAK,MAAM;oBACT,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;oBAErG,OAAO;wBACL,GAAG,KAAK;wBACR,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI,EAAE;wBACpB,YAAY,EACV,CAAC,KAAK,CAAC,aAAa,IAAI,KAAK,CAAC,WAAW,KAAK,KAAK,CAAC,aAAa;4BAC/D,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE;4BACrB,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,CAAC,aAAa,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,oCAAoC;wBAEhH,KAAK,EAAE,WAAW;wBAClB,aAAa,EAAE,YAAY;qBAC5B,CAAA;gBACH;oBACE,OAAO,KAAK,CAAA;YAChB,CAAC;QACH,CAAC,CAAC,CAAA;IAhGF,CAAC;IAkGO,aAAa,CAAC,KAA0B,EAAE,KAAmB;QACnE,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,EAAE,CAAA;QACX,CAAC;QAED,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAEzC,OAAO,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IAC9F,CAAC;IAEO,iBAAiB,CAAC,KAA0B;QAClD,OAAO,IAAI,UAAU,CAAC,CAAC,UAAmC,EAAE,EAAE;YAC5D,IAAI,OAAO,CAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE;gBAC1C,IAAI,CAAC;oBACH,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAA;oBACpC,IAAI,KAAK,CAAC,YAAY,EAAE,IAAI,KAAK,OAAO,EAAE,CAAC;wBACzC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,CAAC,YAAY,CAAC,WAAW,EAAE,SAAS,EAAE,KAAK,CAAC,YAAY,CAAC,SAAS,EAAE,CAAC,CAAA;oBAC1H,CAAC;yBAAM,IAAI,KAAK,CAAC,YAAY,EAAE,IAAI,KAAK,UAAU,EAAE,CAAC;wBACnD,MAAM,QAAQ,GAAuB,MAAM,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,CAAA;wBACjG,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,CAAC,YAAY,CAAC,WAAW,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAA;oBACnG,CAAC;yBAAM,IAAI,KAAK,CAAC,YAAY,EAAE,IAAI,KAAK,MAAM,EAAE,CAAC;wBAC/C,6BAA6B;wBAC7B,MAAM,QAAQ,GAAuB,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,CAAA;wBAC7F,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,YAAY,CAAC,WAAW,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAA;oBAC/F,CAAC;yBAAM,CAAC;wBACN,2DAA2D;wBAC3D,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAA;oBACtC,CAAC;oBAED,OAAO,EAAE,CAAA;gBACX,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,CAAC,KAAK,CAAC,CAAA;gBACf,CAAC;YACH,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;gBACd,UAAU,CAAC,QAAQ,EAAE,CAAA;YACvB,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAAC,WAAwB;QACtD,OAAO,IAAI,CAAC,iBAAiB,CAAC,kBAAkB,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,iBAAiB,EAAE,CAAC,CAAA;IACzI,CAAC;IAEO,KAAK,CAAC,aAAa,CAAC,WAAwB;QAClD,MAAM,SAAS,GAAW,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAA;QAE9D,OAAO,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,SAAS,CAAC,CAAA;IACxD,CAAC;IAEO,iBAAiB,CAAC,WAAwB,EAAE,SAAwB;QAC1E,OAAO,oBAAoB,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,WAAW,EAAE,IAAI,SAAS,EAAE,CAAA;IAC3H,CAAC;IAEO,kBAAkB,CAAC,WAAwB;QACjD,OAAO,mBAAmB,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,CAAA;IAC7G,CAAC;+GA5JU,mBAAmB;mHAAnB,mBAAmB;;4FAAnB,mBAAmB;kBAD/B,UAAU","sourcesContent":["import { DEFAULT_CURRENCY_SYMBOL_URL, FilesystemService, SymbolInput, SymbolValue } from '@wallfree-dev/angular-core'\nimport { Injectable } from '@angular/core'\nimport { ComponentStore, tapResponse } from '@ngrx/component-store'\nimport { Observable, Subscriber } from 'rxjs'\nimport { map, repeat, switchMap, withLatestFrom } from 'rxjs/operators'\n\nimport { CurrencySymbolState } from './currency-symbol.types'\n\nconst initialStore: CurrencySymbolState = {\n  src: DEFAULT_CURRENCY_SYMBOL_URL,\n\n  input: undefined,\n  fallbackInput: undefined,\n  inputs: []\n}\n\n@Injectable()\nexport class CurrencySymbolStore extends ComponentStore<CurrencySymbolState> {\n  constructor(private readonly filesystemService: FilesystemService) {\n    super(initialStore)\n  }\n\n  public readonly onError$ = this.effect((trigger$: Observable<void>) => {\n    return trigger$.pipe(\n      withLatestFrom(this.state$),\n      switchMap(([, state]: [void, CurrencySymbolState]) => {\n        return this.loadFallbackImage(state).pipe(\n          map((value: SymbolValue) => {\n            if (value.kind === 'lazy' && value.url === undefined) {\n              return !state.fallbackInput || value.symbolInput === state.fallbackInput\n                ? { kind: 'default' }\n                : { kind: 'asset', symbolInput: state.fallbackInput, extension: 'svg' } // try again with fallback symbol\n            } else {\n              return value\n            }\n          }),\n          tapResponse(\n            (value: SymbolValue) => this.setSrc(value),\n            () => this.setSrc({ kind: 'default' })\n          )\n        )\n      }),\n      repeat()\n    )\n  })\n\n  public readonly setInitialSrc = this.updater((state: CurrencySymbolState, inputs: SymbolInput[]) => {\n    const input: SymbolInput | undefined = inputs[0]\n    const fallbackInput: SymbolInput | undefined = inputs[1]\n\n    return {\n      ...state,\n      src: input ? this.getSymbolAssetURL(input, 'svg') /* use .svg by default */ : state.src,\n      fallbackType: input ? { kind: 'asset', symbolInput: input, extension: 'png' } /* use .png as a fallback */ : state.fallbackType,\n\n      input,\n      fallbackInput,\n      inputs\n    }\n  })\n\n  private readonly setSrc = this.updater((state: CurrencySymbolState, value: SymbolValue) => {\n    switch (value.kind) {\n      case 'default':\n        return {\n          ...state,\n          src: DEFAULT_CURRENCY_SYMBOL_URL,\n\n          input: undefined,\n          fallbackInput: undefined\n        }\n      case 'asset':\n        const { current: assetCurrent, fallback: assetFallback } = this.getNextInputs(state, value.symbolInput)\n\n        return {\n          ...state,\n          src: this.getSymbolAssetURL(value.symbolInput, value.extension),\n          fallbackType:\n            value.extension === 'svg'\n              ? { kind: 'asset', symbolInput: value.symbolInput, extension: 'png' } /* use .png as a fallback */\n              : { kind: 'isolated', symbolInput: value.symbolInput } /* try loading external isolated image as a fallback */,\n\n          input: assetCurrent,\n          fallbackInput: assetFallback\n        }\n      case 'isolated':\n        const { current: isolatedCurrent, fallback: isolatedFallback } = this.getNextInputs(state, value.symbolInput)\n\n        return {\n          ...state,\n          src: value.url ?? '',\n          fallbackType:\n            !state.fallbackInput || value.symbolInput === state.fallbackInput\n              ? { kind: 'lazy', symbolInput: value.symbolInput } /* try loading external image as a fallback */\n              : { kind: 'asset', symbolInput: state.fallbackInput, extension: 'svg' } /* try again with fallback symbol */,\n\n          input: isolatedCurrent,\n          fallbackInput: isolatedFallback\n        }\n      case 'lazy':\n        const { current: lazyCurrent, fallback: lazyFallback } = this.getNextInputs(state, value.symbolInput)\n\n        return {\n          ...state,\n          src: value.url ?? '',\n          fallbackType:\n            !state.fallbackInput || value.symbolInput === state.fallbackInput\n              ? { kind: 'default' }\n              : { kind: 'asset', symbolInput: state.fallbackInput, extension: 'svg' } /* try again with fallback symbol */,\n\n          input: lazyCurrent,\n          fallbackInput: lazyFallback\n        }\n      default:\n        return state\n    }\n  })\n\n  private getNextInputs(state: CurrencySymbolState, input?: SymbolInput): { current?: SymbolInput; fallback?: SymbolInput } {\n    if (!input) {\n      return {}\n    }\n\n    const index = state.inputs.indexOf(input)\n\n    return index > -1 ? { current: state.inputs[index], fallback: state.inputs[index + 1] } : {}\n  }\n\n  private loadFallbackImage(state: CurrencySymbolState): Observable<SymbolValue> {\n    return new Observable((subscriber: Subscriber<SymbolValue>) => {\n      new Promise<void>(async (resolve, reject) => {\n        try {\n          subscriber.next({ kind: 'default' })\n          if (state.fallbackType?.kind === 'asset') {\n            subscriber.next({ kind: 'asset', symbolInput: state.fallbackType.symbolInput, extension: state.fallbackType.extension })\n          } else if (state.fallbackType?.kind === 'isolated') {\n            const imageURI: string | undefined = await this.loadIsolatedImage(state.fallbackType.symbolInput)\n            subscriber.next({ kind: 'isolated', symbolInput: state.fallbackType.symbolInput, url: imageURI })\n          } else if (state.fallbackType?.kind === 'lazy') {\n            // try loading external image\n            const imageURI: string | undefined = await this.loadLazyImage(state.fallbackType.symbolInput)\n            subscriber.next({ kind: 'lazy', symbolInput: state.fallbackType.symbolInput, url: imageURI })\n          } else {\n            // no image was found for the symbol, use the generic image\n            subscriber.next({ kind: 'default' })\n          }\n\n          resolve()\n        } catch (error) {\n          reject(error)\n        }\n      }).finally(() => {\n        subscriber.complete()\n      })\n    })\n  }\n\n  private async loadIsolatedImage(symbolInput: SymbolInput): Promise<string | undefined> {\n    return this.filesystemService.readIsolatedSymbol(symbolInput.caseSensitive ? symbolInput.value : symbolInput.value.toLocaleLowerCase())\n  }\n\n  private async loadLazyImage(symbolInput: SymbolInput): Promise<string | undefined> {\n    const imagePath: string = this.getSymbolImagePath(symbolInput)\n\n    return this.filesystemService.readLazyImage(imagePath)\n  }\n\n  private getSymbolAssetURL(symbolInput: SymbolInput, extension: 'svg' | 'png'): string {\n    return `./assets/symbols/${symbolInput.caseSensitive ? symbolInput.value : symbolInput.value.toLowerCase()}.${extension}`\n  }\n\n  private getSymbolImagePath(symbolInput: SymbolInput): string {\n    return `/images/symbols/${symbolInput.caseSensitive ? symbolInput.value : symbolInput.value.toLowerCase()}`\n  }\n}\n"]}

package/esm2022/lib/components/currency-symbol/currency-symbol.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VycmVuY3ktc3ltYm9sLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9jb21wb25lbnRzL2N1cnJlbmN5LXN5bWJvbC9jdXJyZW5jeS1zeW1ib2wudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFN5bWJvbElucHV0LCBTeW1ib2xUeXBlIH0gZnJvbSAnQHdhbGxmcmVlLWRldi9hbmd1bGFyLWNvcmUnXG5cbmV4cG9ydCBpbnRlcmZhY2UgQ3VycmVuY3lTeW1ib2xTdGF0ZSB7XG4gIHNyYzogc3RyaW5nXG4gIGZhbGxiYWNrVHlwZT86IFN5bWJvbFR5cGVcblxuICBpbnB1dDogU3ltYm9sSW5wdXQgfCB1bmRlZmluZWRcbiAgZmFsbGJhY2tJbnB1dDogU3ltYm9sSW5wdXQgfCB1bmRlZmluZWRcbiAgaW5wdXRzOiBTeW1ib2xJbnB1dFtdXG59XG4iXX0=

package/esm2022/lib/components/isolated-modules-details/isolated-modules-details.facade.mjs

@@ -0,0 +1,28 @@
+import { ISOLATED_MODULES_PLUGIN } from '@wallfree-dev/angular-core';
+import { Injectable } from '@angular/core';
+import { BaseNgRxFacade } from '../../base/base-ngrx.facade';
+import { IsolatedModulesDetailsStore } from './isolated-modules-details.store';
+import * as i0 from "@angular/core";
+import * as i1 from "./isolated-modules-details.store";
+export class IsolatedModulesDetailsNgRxFacade extends BaseNgRxFacade {
+    constructor(store) {
+        super(store);
+        this.manifest$ = this.store.select((state) => state.manifest);
+        this.isVerified$ = this.store.select((state) => state.isVerified);
+    }
+    initWithData(metadata) {
+        this.store.loadModuleData(metadata);
+    }
+    onDataChanged(metadata) {
+        this.store.loadModuleData(metadata);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IsolatedModulesDetailsNgRxFacade, deps: [{ token: i1.IsolatedModulesDetailsStore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IsolatedModulesDetailsNgRxFacade }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IsolatedModulesDetailsNgRxFacade, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.IsolatedModulesDetailsStore }] });
+export const isolatedModulesDetailsNgRxFacade = (injector) => {
+    return new IsolatedModulesDetailsNgRxFacade(new IsolatedModulesDetailsStore(injector.get(ISOLATED_MODULES_PLUGIN)));
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/isolated-modules-details/isolated-modules-details.store.mjs

@@ -0,0 +1,76 @@
+import { ISOLATED_MODULES_PLUGIN, UIResourceStatus } from '@wallfree-dev/angular-core';
+import { Inject, Injectable } from '@angular/core';
+import { ComponentStore } from '@ngrx/component-store';
+import { from, of } from 'rxjs';
+import { first, map, switchMap, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+const initialState = {
+    manifest: {
+        status: UIResourceStatus.IDLE,
+        value: undefined
+    },
+    path: {
+        status: UIResourceStatus.IDLE,
+        value: undefined
+    },
+    isVerified: {
+        status: UIResourceStatus.IDLE,
+        value: undefined
+    }
+};
+export class IsolatedModulesDetailsStore extends ComponentStore {
+    constructor(isolatedModules) {
+        super(initialState);
+        this.isolatedModules = isolatedModules;
+        this.loadModuleData = this.effect((metadata$) => {
+            return metadata$.pipe(switchMap((metadata) => metadata.type === 'preview'
+                ? from(this.verifyModule(metadata)).pipe(first(), map((isVerified) => ({ manifest: metadata.manifest, isVerified })))
+                : of({ manifest: metadata.manifest, isVerified: true })), tap({
+                next: ({ manifest, isVerified }) => this.setData({ manifest, isVerified }),
+                error: () => this.onError()
+            }));
+        });
+        this.setData = this.updater((state, data) => {
+            return {
+                ...state,
+                manifest: {
+                    status: UIResourceStatus.SUCCESS,
+                    value: data.manifest
+                },
+                isVerified: {
+                    status: UIResourceStatus.SUCCESS,
+                    value: data.isVerified
+                }
+            };
+        });
+        this.onError = this.updater((state) => {
+            return {
+                ...state,
+                manifest: {
+                    status: UIResourceStatus.ERROR,
+                    value: state.manifest.value
+                },
+                isVerified: {
+                    status: UIResourceStatus.ERROR,
+                    value: state.isVerified.value
+                }
+            };
+        });
+    }
+    async verifyModule(metadata) {
+        const { verified } = await this.isolatedModules.verifyDynamicModule({
+            path: `${metadata.path}/${metadata.root}`.replace(/\/+$/, ''),
+            directory: metadata.directory
+        });
+        return verified;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IsolatedModulesDetailsStore, deps: [{ token: ISOLATED_MODULES_PLUGIN }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IsolatedModulesDetailsStore }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IsolatedModulesDetailsStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ISOLATED_MODULES_PLUGIN]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/isolated-modules-details/isolated-modules-details.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXNvbGF0ZWQtbW9kdWxlcy1kZXRhaWxzLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9jb21wb25lbnRzL2lzb2xhdGVkLW1vZHVsZXMtZGV0YWlscy9pc29sYXRlZC1tb2R1bGVzLWRldGFpbHMudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElzb2xhdGVkTW9kdWxlTWFuaWZlc3QsIFVJUmVzb3VyY2UgfSBmcm9tICdAd2FsbGZyZWUtZGV2L2FuZ3VsYXItY29yZSdcblxuZXhwb3J0IGludGVyZmFjZSBJc29sYXRlZE1vZHVsZXNEZXRhaWxzU3RhdGUge1xuICBtYW5pZmVzdDogVUlSZXNvdXJjZTxJc29sYXRlZE1vZHVsZU1hbmlmZXN0PlxuICBwYXRoOiBVSVJlc291cmNlPHN0cmluZz5cbiAgaXNWZXJpZmllZDogVUlSZXNvdXJjZTxib29sZWFuPlxufVxuIl19

package/esm2022/lib/components/isolated-modules-list/isolated-modules-list.facade.mjs

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import { BaseNgRxFacade } from '../../base/base-ngrx.facade';
+import { IsolatedModulesListStore } from './isolated-modules-list.store';
+import * as i0 from "@angular/core";
+import * as i1 from "./isolated-modules-list.store";
+export class IsolatedModulesListNgRxFacade extends BaseNgRxFacade {
+    constructor(store) {
+        super(store);
+        this.modules$ = this.store.select((state) => state.filteredModules);
+    }
+    updateModules(modules, query) {
+        this.store.setModules({ modules, query });
+    }
+    filterModules(query) {
+        this.store.filterModules(query);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IsolatedModulesListNgRxFacade, deps: [{ token: i1.IsolatedModulesListStore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IsolatedModulesListNgRxFacade }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IsolatedModulesListNgRxFacade, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.IsolatedModulesListStore }] });
+export const isolatedModulesListNgRxFacade = (_injector) => {
+    return new IsolatedModulesListNgRxFacade(new IsolatedModulesListStore());
+};
+//# sourceMappingURL=data:application/json;base64,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