@formio/angular 7.5.0-rc.2 → 7.5.0-rc.3

package/dist/angular-formio/esm2022/resource/resource.component.mjs

@@ -0,0 +1,72 @@
+import { Component } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "./resource.service";
+import * as i2 from "@angular/router";
+import * as i3 from "@formio/angular/auth";
+import * as i4 from "@angular/common";
+function FormioResourceComponent_li_7_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "li", 4)(1, "a", 7);
+    i0.ɵɵtext(2, "Edit");
+    i0.ɵɵelementEnd()();
+} }
+function FormioResourceComponent_li_8_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "li", 4)(1, "a", 8);
+    i0.ɵɵelement(2, "span", 9);
+    i0.ɵɵelementEnd()();
+} }
+export class FormioResourceComponent {
+    service;
+    route;
+    auth;
+    router;
+    perms = { delete: false, edit: false };
+    routerSubscription;
+    constructor(service, route, auth, router) {
+        this.service = service;
+        this.route = route;
+        this.auth = auth;
+        this.router = router;
+    }
+    ngOnInit() {
+        this.init();
+        this.routerSubscription = this.router.events.subscribe((event) => {
+            if (event instanceof NavigationEnd) {
+                this.init();
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.routerSubscription.unsubscribe();
+    }
+    init() {
+        return this.service.init(this.route).then(() => this.auth.ready.then(() => this.service.formFormio.userPermissions(this.auth.user, this.service.form, this.service.resource).then((perms) => {
+            this.perms.delete = perms.delete;
+            this.perms.edit = perms.edit;
+            return this.service.resource;
+        })));
+    }
+    static ɵfac = function FormioResourceComponent_Factory(t) { return new (t || FormioResourceComponent)(i0.ɵɵdirectiveInject(i1.FormioResourceService), i0.ɵɵdirectiveInject(i2.ActivatedRoute), i0.ɵɵdirectiveInject(i3.FormioAuthService), i0.ɵɵdirectiveInject(i2.Router)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: FormioResourceComponent, selectors: [["ng-component"]], decls: 10, vars: 2, consts: [[1, "nav", "nav-tabs", 2, "margin-bottom", "10px"], [1, "nav-item"], ["routerLink", "../", 1, "nav-link"], [1, "fa", "fa-chevron-left", "bi", "bi-chevron-left"], ["routerLinkActive", "active", 1, "nav-item"], ["routerLink", "view", "routerLinkActive", "active", 1, "nav-link"], ["class", "nav-item", "routerLinkActive", "active", 4, "ngIf"], ["routerLink", "edit", "routerLinkActive", "active", 1, "nav-link"], ["routerLink", "delete", "routerLinkActive", "active", 1, "nav-link"], [1, "fa", "fa-trash", "bi", "bi-trash"]], template: function FormioResourceComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "ul", 0)(1, "li", 1)(2, "a", 2);
+            i0.ɵɵelement(3, "em", 3);
+            i0.ɵɵelementEnd()();
+            i0.ɵɵelementStart(4, "li", 4)(5, "a", 5);
+            i0.ɵɵtext(6, "View");
+            i0.ɵɵelementEnd()();
+            i0.ɵɵtemplate(7, FormioResourceComponent_li_7_Template, 3, 0, "li", 6)(8, FormioResourceComponent_li_8_Template, 3, 0, "li", 6);
+            i0.ɵɵelementEnd();
+            i0.ɵɵelement(9, "router-outlet");
+        } if (rf & 2) {
+            i0.ɵɵadvance(7);
+            i0.ɵɵproperty("ngIf", ctx.perms.edit);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngIf", ctx.perms.delete);
+        } }, dependencies: [i4.NgIf, i2.RouterOutlet, i2.RouterLink, i2.RouterLinkActive], encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormioResourceComponent, [{
+        type: Component,
+        args: [{ template: "<ul class=\"nav nav-tabs\" style=\"margin-bottom: 10px\">\n  <li class=\"nav-item\"><a class=\"nav-link\" routerLink=\"../\"><em class=\"fa fa-chevron-left bi bi-chevron-left\"></em></a></li>\n  <li class=\"nav-item\" routerLinkActive=\"active\"><a class=\"nav-link\" routerLink=\"view\" routerLinkActive=\"active\">View</a></li>\n  <li class=\"nav-item\" routerLinkActive=\"active\" *ngIf=\"perms.edit\"><a class=\"nav-link\" routerLink=\"edit\" routerLinkActive=\"active\">Edit</a></li>\n  <li class=\"nav-item\" routerLinkActive=\"active\" *ngIf=\"perms.delete\"><a class=\"nav-link\" routerLink=\"delete\" routerLinkActive=\"active\"><span class=\"fa fa-trash bi bi-trash\"></span></a></li>\n</ul>\n<router-outlet></router-outlet>\n" }]
+    }], () => [{ type: i1.FormioResourceService }, { type: i2.ActivatedRoute }, { type: i3.FormioAuthService }, { type: i2.Router }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(FormioResourceComponent, { className: "FormioResourceComponent" }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/angular-formio/esm2022/resource/resource.config.mjs

@@ -0,0 +1,13 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FormioResourceConfig {
+    name = '';
+    form = '';
+    parents = [];
+    static ɵfac = function FormioResourceConfig_Factory(t) { return new (t || FormioResourceConfig)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FormioResourceConfig, factory: FormioResourceConfig.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormioResourceConfig, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb3VyY2UuY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1mb3JtaW8vcmVzb3VyY2Uvc3JjL3Jlc291cmNlLmNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVkzQyxNQUFNLE9BQU8sb0JBQW9CO0lBQy9CLElBQUksR0FBRyxFQUFFLENBQUM7SUFDVixJQUFJLEdBQUcsRUFBRSxDQUFDO0lBQ1YsT0FBTyxHQUFVLEVBQUUsQ0FBQzs4RUFIVCxvQkFBb0I7Z0VBQXBCLG9CQUFvQixXQUFwQixvQkFBb0I7O2lGQUFwQixvQkFBb0I7Y0FEaEMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGludGVyZmFjZSBGb3JtaW9SZXNvdXJjZVJvdXRlQ29uZmlnIHtcbiAgaW5kZXg/OiBhbnk7XG4gIGNyZWF0ZT86IGFueTtcbiAgcmVzb3VyY2U/OiBhbnk7XG4gIHZpZXc/OiBhbnk7XG4gIGVkaXQ/OiBhbnk7XG4gIGRlbGV0ZT86IGFueTtcbn1cblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIEZvcm1pb1Jlc291cmNlQ29uZmlnIHtcbiAgbmFtZSA9ICcnO1xuICBmb3JtID0gJyc7XG4gIHBhcmVudHM6IGFueVtdID0gW107XG59XG4iXX0=

package/dist/angular-formio/esm2022/resource/resource.module.mjs

@@ -0,0 +1,63 @@
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { CommonModule } from '@angular/common';
+import { FormioModule } from '@formio/angular';
+import { FormioAlerts } from '@formio/angular';
+import { FormioGrid } from '@formio/angular/grid';
+import { FormioResourceComponent } from './resource.component';
+import { FormioResourceViewComponent } from './view/view.component';
+import { FormioResourceEditComponent } from './edit/edit.component';
+import { FormioResourceDeleteComponent } from './delete/delete.component';
+import { FormioResourceCreateComponent } from './create/create.component';
+import { FormioResourceIndexComponent } from './index/index.component';
+import { FormioResourceRoutes } from './resource.routes';
+import { extendRouter } from '@formio/angular';
+import * as i0 from "@angular/core";
+export class FormioResource {
+    static forChild(config) {
+        return extendRouter(FormioResource, config, FormioResourceRoutes);
+    }
+    static forRoot(config) {
+        return extendRouter(FormioResource, config, FormioResourceRoutes);
+    }
+    static ɵfac = function FormioResource_Factory(t) { return new (t || FormioResource)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: FormioResource });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+            FormioAlerts
+        ], imports: [CommonModule,
+            FormioModule,
+            FormioGrid,
+            RouterModule] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormioResource, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    FormioModule,
+                    FormioGrid,
+                    RouterModule
+                ],
+                declarations: [
+                    FormioResourceComponent,
+                    FormioResourceCreateComponent,
+                    FormioResourceIndexComponent,
+                    FormioResourceViewComponent,
+                    FormioResourceEditComponent,
+                    FormioResourceDeleteComponent
+                ],
+                providers: [
+                    FormioAlerts
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(FormioResource, { declarations: [FormioResourceComponent,
+        FormioResourceCreateComponent,
+        FormioResourceIndexComponent,
+        FormioResourceViewComponent,
+        FormioResourceEditComponent,
+        FormioResourceDeleteComponent], imports: [CommonModule,
+        FormioModule,
+        FormioGrid,
+        RouterModule] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/angular-formio/esm2022/resource/resource.service.mjs

@@ -0,0 +1,231 @@
+import { EventEmitter, Injectable, Optional } from '@angular/core';
+import { FormioPromiseService } from '@formio/angular';
+import { FormioAlerts } from '@formio/angular';
+import { Formio, Utils } from '@formio/js';
+import _ from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "@formio/angular";
+import * as i2 from "./resource.config";
+import * as i3 from "./resources.service";
+export class FormioResourceService {
+    appConfig;
+    config;
+    resourcesService;
+    initialized = false;
+    form;
+    alerts;
+    resource;
+    resourceUrl;
+    formUrl;
+    formFormio;
+    formio;
+    refresh;
+    resourceResolve;
+    resourceReject;
+    resourceLoaded;
+    resourceLoading;
+    resourceId;
+    resources;
+    ready;
+    readyResolve;
+    readyReject;
+    formLoading;
+    formLoaded;
+    formResolve;
+    formReject;
+    isLoading;
+    constructor(appConfig, config, resourcesService) {
+        this.appConfig = appConfig;
+        this.config = config;
+        this.resourcesService = resourcesService;
+        this.isLoading = true;
+        this.alerts = new FormioAlerts();
+        this.refresh = new EventEmitter();
+    }
+    initialize() {
+        console.warn('FormioResourceService.initialize() has been deprecated.');
+    }
+    setResource(resourceId) {
+        this.resourceLoading = null;
+        this.formLoading = null;
+        this.ready = new Promise((resolve, reject) => {
+            this.readyResolve = resolve;
+            this.readyReject = reject;
+        });
+        this.formLoaded = new Promise((resolve, reject) => {
+            this.formResolve = resolve;
+            this.formReject = reject;
+        });
+        this.resourceLoaded = new Promise((resolve, reject) => {
+            this.resourceResolve = resolve;
+            this.resourceReject = reject;
+        });
+        this.resourceId = resourceId;
+        this.resourceUrl = this.appConfig.appUrl + '/' + this.config.form;
+        if (this.resourceId) {
+            this.resourceUrl += '/submission/' + this.resourceId;
+        }
+        if (this.appConfig && this.appConfig.appUrl) {
+            Formio.setBaseUrl(this.appConfig.apiUrl);
+            Formio.setProjectUrl(this.appConfig.appUrl);
+            Formio.formOnly = this.appConfig.formOnly;
+        }
+        else {
+            console.error('You must provide an AppConfig within your application!');
+        }
+        this.formio = new FormioPromiseService(this.resourceUrl);
+        this.resource = { data: {} };
+    }
+    init(route) {
+        const snapshot = route.snapshot;
+        const reset = snapshot.queryParams?.hasOwnProperty('reset') ? snapshot.queryParams.reset : false;
+        const resourceId = snapshot.params['id'];
+        if (resourceId && (resourceId === this.resourceId) && !reset) {
+            return this.ready;
+        }
+        // Set the resource.
+        this.setResource(resourceId);
+        // Add this resource service to the list of all resources in context.
+        if (this.resourcesService) {
+            this.resources = this.resourcesService.resources;
+            this.resources[this.config.name] = this;
+        }
+        if (this.resourceId) {
+            return this.loadForm()
+                .then(() => this.loadResource())
+                .then(() => this.readyResolve(this.form))
+                .catch((err) => this.readyReject(err));
+        }
+        return this.loadForm()
+            .then(() => this.readyResolve(this.form))
+            .catch((err) => this.readyReject(err));
+    }
+    onError(error) {
+        this.alerts.setAlert({
+            type: 'danger',
+            message: error.message || error
+        });
+        if (this.resourcesService) {
+            this.resourcesService.error.emit(error);
+        }
+        throw error;
+    }
+    onFormError(err) {
+        this.formReject(err);
+        this.onError(err);
+    }
+    loadForm() {
+        if (this.formLoading) {
+            return this.formLoading;
+        }
+        this.formUrl = this.appConfig.appUrl + '/' + this.config.form;
+        this.formFormio = new FormioPromiseService(this.formUrl);
+        this.isLoading = true;
+        this.formLoading = this.formFormio
+            .loadForm()
+            .then((form) => {
+            this.form = form;
+            this.formResolve(form);
+            this.isLoading = false;
+            this.loadParents();
+            return form;
+        }, (err) => this.onFormError(err))
+            .catch((err) => this.onFormError(err));
+        return this.formLoading;
+    }
+    loadParents() {
+        if (!this.config.parents || !this.config.parents.length) {
+            return Promise.resolve([]);
+        }
+        if (!this.resourcesService) {
+            console.warn('You must provide the FormioResources within your application to use nested resources.');
+            return Promise.resolve([]);
+        }
+        return this.formLoading.then((form) => {
+            // Iterate through the list of parents.
+            const _parentsLoaded = [];
+            this.config.parents.forEach((parent) => {
+                const resourceName = parent.resource || parent;
+                const resourceField = parent.field || parent;
+                const filterResource = parent.hasOwnProperty('filter') ? parent.filter : true;
+                if (this.resources.hasOwnProperty(resourceName) && this.resources[resourceName].resourceLoaded) {
+                    _parentsLoaded.push(this.resources[resourceName].resourceLoaded.then((resource) => {
+                        let parentPath = '';
+                        Utils.eachComponent(form.components, (component, path) => {
+                            if (component.key === resourceField) {
+                                component.hidden = true;
+                                component.clearOnHide = false;
+                                _.set(this.resource.data, path, resource);
+                                parentPath = path;
+                                return true;
+                            }
+                        });
+                        return {
+                            name: parentPath,
+                            filter: filterResource,
+                            resource
+                        };
+                    }));
+                }
+            });
+            // When all the parents have loaded, emit that to the onParents emitter.
+            return Promise.all(_parentsLoaded).then((parents) => {
+                this.refresh.emit({
+                    form: form,
+                    submission: this.resource
+                });
+                return parents;
+            });
+        });
+    }
+    onSubmissionError(err) {
+        this.onError(err);
+        this.resourceReject(err);
+    }
+    loadResource() {
+        if (this.resourceLoading) {
+            return this.resourceLoading;
+        }
+        this.isLoading = true;
+        this.resourceLoading = this.formio
+            .loadSubmission(null, { ignoreCache: true })
+            .then((resource) => {
+            this.resource = resource;
+            this.isLoading = false;
+            this.refresh.emit({
+                property: 'submission',
+                value: this.resource
+            });
+            this.resourceResolve(resource);
+            return resource;
+        }, (err) => this.onSubmissionError(err))
+            .catch((err) => this.onSubmissionError(err));
+        return this.resourceLoading;
+    }
+    save(resource) {
+        const formio = resource._id ? this.formio : this.formFormio;
+        return formio
+            .saveSubmission(resource)
+            .then((saved) => {
+            this.resource = saved;
+            return saved;
+        }, (err) => this.onError(err))
+            .catch((err) => this.onError(err));
+    }
+    remove() {
+        return this.formio
+            .deleteSubmission()
+            .then(() => {
+            this.resource = null;
+        }, (err) => this.onError(err))
+            .catch((err) => this.onError(err));
+    }
+    static ɵfac = function FormioResourceService_Factory(t) { return new (t || FormioResourceService)(i0.ɵɵinject(i1.FormioAppConfig), i0.ɵɵinject(i2.FormioResourceConfig), i0.ɵɵinject(i3.FormioResources, 8)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FormioResourceService, factory: FormioResourceService.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormioResourceService, [{
+        type: Injectable
+    }], () => [{ type: i1.FormioAppConfig }, { type: i2.FormioResourceConfig }, { type: i3.FormioResources, decorators: [{
+                type: Optional
+            }] }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource.service.js","sourceRoot":"","sources":["../../../../projects/angular-formio/resource/src/resource.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAInE,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAG/C,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,CAAC,MAAM,QAAQ,CAAC;;;;;AAGvB,MAAM,OAAO,qBAAqB;IA8BvB;IACA;IACY;IA/Bd,WAAW,GAAG,KAAK,CAAC;IACpB,IAAI,CAAM;IACV,MAAM,CAAe;IACrB,QAAQ,CAAM;IACd,WAAW,CAAU;IACrB,OAAO,CAAS;IAChB,UAAU,CAAuB;IACjC,MAAM,CAAuB;IAC7B,OAAO,CAAmC;IAE1C,eAAe,CAAM;IACrB,cAAc,CAAM;IACpB,cAAc,CAAgB;IAE9B,eAAe,CAAgB;IAC/B,UAAU,CAAU;IACpB,SAAS,CAAM;IAEf,KAAK,CAAgB;IACrB,YAAY,CAAM;IAClB,WAAW,CAAM;IAEjB,WAAW,CAAgB;IAC3B,UAAU,CAAe;IACzB,WAAW,CAAM;IACjB,UAAU,CAAM;IAChB,SAAS,CAAU;IAE1B,YACS,SAA0B,EAC1B,MAA4B,EAChB,gBAAiC;QAF7C,cAAS,GAAT,SAAS,CAAiB;QAC1B,WAAM,GAAN,MAAM,CAAsB;QAChB,qBAAgB,GAAhB,gBAAgB,CAAiB;QAEpD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QACjC,IAAI,CAAC,OAAO,GAAG,IAAI,YAAY,EAAE,CAAC;IACpC,CAAC;IAED,UAAU;QACR,OAAO,CAAC,IAAI,CAAC,yDAAyD,CAAC,CAAC;IAC1E,CAAC;IAED,WAAW,CAAC,UAAe;QACzB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,KAAK,GAAG,IAAI,OAAO,CAAC,CAAC,OAAY,EAAE,MAAW,EAAE,EAAE;YACrD,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC;YAC5B,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;QAC5B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,UAAU,GAAG,IAAI,OAAO,CAAC,CAAC,OAAY,EAAE,MAAW,EAAE,EAAE;YAC1D,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC;YAC3B,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC;QAC3B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,cAAc,GAAG,IAAI,OAAO,CAAC,CAAC,OAAY,EAAE,MAAW,EAAE,EAAE;YAC9D,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC;YAC/B,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC;QAC/B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;QAClE,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,IAAI,CAAC,WAAW,IAAI,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC;QACvD,CAAC;QACD,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;YAC5C,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YACzC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YAC5C,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;QAC5C,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,KAAK,CAAC,wDAAwD,CAAC,CAAC;QAC1E,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,IAAI,oBAAoB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACzD,IAAI,CAAC,QAAQ,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;IAC/B,CAAC;IAED,IAAI,CAAC,KAAqB;QACxB,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QAChC,MAAM,KAAK,GAAG,QAAQ,CAAC,WAAW,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;QACjG,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACzC,IAAI,UAAU,IAAI,CAAC,UAAU,KAAK,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAC7D,OAAO,IAAI,CAAC,KAAK,CAAC;QACpB,CAAC;QAED,oBAAoB;QACpB,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;QAE7B,qEAAqE;QACrE,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC;YACjD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QAC1C,CAAC;QAED,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC,QAAQ,EAAE;iBACnB,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;iBAC/B,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;iBACxC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3C,CAAC;QAED,OAAO,IAAI,CAAC,QAAQ,EAAE;aACnB,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACxC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3C,CAAC;IAED,OAAO,CAAC,KAAU;QAChB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;YACnB,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,KAAK;SAChC,CAAC,CAAC;QACH,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1C,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;IAED,WAAW,CAAC,GAAQ;QAClB,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACpB,CAAC;IAED,QAAQ;QACN,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,OAAO,IAAI,CAAC,WAAW,CAAC;QAC1B,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;QAC9D,IAAI,CAAC,UAAU,GAAG,IAAI,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACzD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU;aAC/B,QAAQ,EAAE;aACV,IAAI,CACH,CAAC,IAAS,EAAE,EAAE;YACZ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;YACjB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YACvB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,OAAO,IAAI,CAAC;QACd,CAAC,EACD,CAAC,GAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CACpC;aACA,KAAK,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;QAC9C,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,WAAW;QACT,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YACxD,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAC7B,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC3B,OAAO,CAAC,IAAI,CACV,uFAAuF,CACxF,CAAC;YACF,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAC7B,CAAC;QACD,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;YACpC,uCAAuC;YACvC,MAAM,cAAc,GAAwB,EAAE,CAAC;YAC/C,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,MAAW,EAAE,EAAE;gBAC1C,MAAM,YAAY,GAAG,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC;gBAC/C,MAAM,aAAa,GAAG,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC;gBAC7C,MAAM,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;gBAC9E,IAAI,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,YAAY,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,cAAc,EAAE,CAAC;oBAC/F,cAAc,CAAC,IAAI,CACjB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,QAAa,EAAE,EAAE;wBACjE,IAAI,UAAU,GAAG,EAAE,CAAC;wBACpB,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,SAAS,EAAE,IAAI,EAAE,EAAE;4BACvD,IAAI,SAAS,CAAC,GAAG,KAAK,aAAa,EAAE,CAAC;gCACpC,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC;gCACxB,SAAS,CAAC,WAAW,GAAG,KAAK,CAAC;gCAC9B,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;gCAC1C,UAAU,GAAG,IAAI,CAAC;gCAClB,OAAO,IAAI,CAAC;4BACd,CAAC;wBACH,CAAC,CAAC,CAAC;wBACH,OAAO;4BACL,IAAI,EAAE,UAAU;4BAChB,MAAM,EAAE,cAAc;4BACtB,QAAQ;yBACT,CAAC;oBACJ,CAAC,CAAC,CACH,CAAC;gBACJ,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,wEAAwE;YACxE,OAAO,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,CAAC,OAAY,EAAE,EAAE;gBACvD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;oBAChB,IAAI,EAAE,IAAI;oBACV,UAAU,EAAE,IAAI,CAAC,QAAQ;iBAC1B,CAAC,CAAC;gBACH,OAAO,OAAO,CAAC;YACjB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED,iBAAiB,CAAC,GAAQ;QACxB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAClB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED,YAAY;QACV,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,OAAO,IAAI,CAAC,eAAe,CAAC;QAC9B,CAAC;QACD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,MAAM;aAC/B,cAAc,CAAC,IAAI,EAAE,EAAC,WAAW,EAAE,IAAI,EAAC,CAAC;aACzC,IAAI,CACH,CAAC,QAAa,EAAE,EAAE;YAChB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;YACzB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;gBAChB,QAAQ,EAAE,YAAY;gBACtB,KAAK,EAAE,IAAI,CAAC,QAAQ;aACrB,CAAC,CAAC;YACH,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;YAC/B,OAAO,QAAQ,CAAC;QAClB,CAAC,EACD,CAAC,GAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAC1C;aACA,KAAK,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC;QACpD,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED,IAAI,CAAC,QAAa;QAChB,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC;QAC5D,OAAO,MAAM;aACV,cAAc,CAAC,QAAQ,CAAC;aACxB,IAAI,CACH,CAAC,KAAU,EAAE,EAAE;YACb,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YACtB,OAAO,KAAK,CAAC;QACf,CAAC,EACD,CAAC,GAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAChC;aACA,KAAK,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,MAAM;aACf,gBAAgB,EAAE;aAClB,IAAI,CACH,GAAG,EAAE;YACH,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACvB,CAAC,EACD,CAAC,GAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAChC;aACA,KAAK,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5C,CAAC;+EAtPU,qBAAqB;gEAArB,qBAAqB,WAArB,qBAAqB;;iFAArB,qBAAqB;cADjC,UAAU;;sBAiCN,QAAQ","sourcesContent":["import { EventEmitter, Injectable, Optional } from '@angular/core';\nimport { ActivatedRoute } from '@angular/router';\nimport { FormioResourceConfig } from './resource.config';\nimport { FormioResources } from './resources.service';\nimport { FormioPromiseService } from '@formio/angular';\nimport { FormioAlerts } from '@formio/angular';\nimport { FormioAppConfig } from '@formio/angular';\nimport { FormioRefreshValue } from '@formio/angular';\nimport { Formio, Utils } from '@formio/js';\nimport _ from 'lodash';\n\n@Injectable()\nexport class FormioResourceService {\n  public initialized = false;\n  public form: any;\n  public alerts: FormioAlerts;\n  public resource: any;\n  public resourceUrl?: string;\n  public formUrl: string;\n  public formFormio: FormioPromiseService;\n  public formio: FormioPromiseService;\n  public refresh: EventEmitter<FormioRefreshValue>;\n\n  public resourceResolve: any;\n  public resourceReject: any;\n  public resourceLoaded?: Promise<any>;\n\n  public resourceLoading?: Promise<any>;\n  public resourceId?: string;\n  public resources: any;\n\n  public ready?: Promise<any>;\n  public readyResolve: any;\n  public readyReject: any;\n\n  public formLoading?: Promise<any>;\n  public formLoaded: Promise<any>;\n  public formResolve: any;\n  public formReject: any;\n  public isLoading: boolean;\n\n  constructor(\n    public appConfig: FormioAppConfig,\n    public config: FormioResourceConfig,\n    @Optional() public resourcesService: FormioResources\n  ) {\n    this.isLoading = true;\n    this.alerts = new FormioAlerts();\n    this.refresh = new EventEmitter();\n  }\n\n  initialize() {\n    console.warn('FormioResourceService.initialize() has been deprecated.');\n  }\n\n  setResource(resourceId: any) {\n    this.resourceLoading = null;\n    this.formLoading = null;\n    this.ready = new Promise((resolve: any, reject: any) => {\n      this.readyResolve = resolve;\n      this.readyReject = reject;\n    });\n    this.formLoaded = new Promise((resolve: any, reject: any) => {\n      this.formResolve = resolve;\n      this.formReject = reject;\n    });\n    this.resourceLoaded = new Promise((resolve: any, reject: any) => {\n      this.resourceResolve = resolve;\n      this.resourceReject = reject;\n    });\n    this.resourceId = resourceId;\n    this.resourceUrl = this.appConfig.appUrl + '/' + this.config.form;\n    if (this.resourceId) {\n      this.resourceUrl += '/submission/' + this.resourceId;\n    }\n    if (this.appConfig && this.appConfig.appUrl) {\n      Formio.setBaseUrl(this.appConfig.apiUrl);\n      Formio.setProjectUrl(this.appConfig.appUrl);\n      Formio.formOnly = this.appConfig.formOnly;\n    } else {\n      console.error('You must provide an AppConfig within your application!');\n    }\n    this.formio = new FormioPromiseService(this.resourceUrl);\n    this.resource = { data: {} };\n  }\n\n  init(route: ActivatedRoute) {\n    const snapshot = route.snapshot;\n    const reset = snapshot.queryParams?.hasOwnProperty('reset') ? snapshot.queryParams.reset : false;\n    const resourceId = snapshot.params['id'];\n    if (resourceId && (resourceId === this.resourceId) && !reset) {\n      return this.ready;\n    }\n\n    // Set the resource.\n    this.setResource(resourceId);\n\n    // Add this resource service to the list of all resources in context.\n    if (this.resourcesService) {\n      this.resources = this.resourcesService.resources;\n      this.resources[this.config.name] = this;\n    }\n\n    if (this.resourceId) {\n      return this.loadForm()\n        .then(() => this.loadResource())\n        .then(() => this.readyResolve(this.form))\n        .catch((err) => this.readyReject(err));\n    }\n\n    return this.loadForm()\n      .then(() => this.readyResolve(this.form))\n      .catch((err) => this.readyReject(err));\n  }\n\n  onError(error: any) {\n    this.alerts.setAlert({\n      type: 'danger',\n      message: error.message || error\n    });\n    if (this.resourcesService) {\n      this.resourcesService.error.emit(error);\n    }\n    throw error;\n  }\n\n  onFormError(err: any) {\n    this.formReject(err);\n    this.onError(err);\n  }\n\n  loadForm() {\n    if (this.formLoading) {\n      return this.formLoading;\n    }\n    this.formUrl = this.appConfig.appUrl + '/' + this.config.form;\n    this.formFormio = new FormioPromiseService(this.formUrl);\n    this.isLoading = true;\n    this.formLoading = this.formFormio\n      .loadForm()\n      .then(\n        (form: any) => {\n          this.form = form;\n          this.formResolve(form);\n          this.isLoading = false;\n          this.loadParents();\n          return form;\n        },\n        (err: any) => this.onFormError(err)\n      )\n      .catch((err: any) => this.onFormError(err));\n    return this.formLoading;\n  }\n\n  loadParents() {\n    if (!this.config.parents || !this.config.parents.length) {\n      return Promise.resolve([]);\n    }\n    if (!this.resourcesService) {\n      console.warn(\n        'You must provide the FormioResources within your application to use nested resources.'\n      );\n      return Promise.resolve([]);\n    }\n    return this.formLoading.then((form) => {\n      // Iterate through the list of parents.\n      const _parentsLoaded: Array<Promise<any>> = [];\n      this.config.parents.forEach((parent: any) => {\n        const resourceName = parent.resource || parent;\n        const resourceField = parent.field || parent;\n        const filterResource = parent.hasOwnProperty('filter') ? parent.filter : true;\n        if (this.resources.hasOwnProperty(resourceName) && this.resources[resourceName].resourceLoaded) {\n          _parentsLoaded.push(\n            this.resources[resourceName].resourceLoaded.then((resource: any) => {\n              let parentPath = '';\n              Utils.eachComponent(form.components, (component, path) => {\n                if (component.key === resourceField) {\n                  component.hidden = true;\n                  component.clearOnHide = false;\n                  _.set(this.resource.data, path, resource);\n                  parentPath = path;\n                  return true;\n                }\n              });\n              return {\n                name: parentPath,\n                filter: filterResource,\n                resource\n              };\n            })\n          );\n        }\n      });\n\n      // When all the parents have loaded, emit that to the onParents emitter.\n      return Promise.all(_parentsLoaded).then((parents: any) => {\n        this.refresh.emit({\n          form: form,\n          submission: this.resource\n        });\n        return parents;\n      });\n    });\n  }\n\n  onSubmissionError(err: any) {\n    this.onError(err);\n    this.resourceReject(err);\n  }\n\n  loadResource() {\n    if (this.resourceLoading) {\n      return this.resourceLoading;\n    }\n    this.isLoading = true;\n    this.resourceLoading = this.formio\n      .loadSubmission(null, {ignoreCache: true})\n      .then(\n        (resource: any) => {\n          this.resource = resource;\n          this.isLoading = false;\n          this.refresh.emit({\n            property: 'submission',\n            value: this.resource\n          });\n          this.resourceResolve(resource);\n          return resource;\n        },\n        (err: any) => this.onSubmissionError(err)\n      )\n      .catch((err: any) => this.onSubmissionError(err));\n    return this.resourceLoading;\n  }\n\n  save(resource: any) {\n    const formio = resource._id ? this.formio : this.formFormio;\n    return formio\n      .saveSubmission(resource)\n      .then(\n        (saved: any) => {\n          this.resource = saved;\n          return saved;\n        },\n        (err: any) => this.onError(err)\n      )\n      .catch((err: any) => this.onError(err));\n  }\n\n  remove() {\n    return this.formio\n      .deleteSubmission()\n      .then(\n        () => {\n          this.resource = null;\n        },\n        (err: any) => this.onError(err)\n      )\n      .catch((err: any) => this.onError(err));\n  }\n}\n"]}

package/dist/angular-formio/esm2022/resource/resources.service.mjs

@@ -0,0 +1,25 @@
+import { Injectable, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@formio/angular/auth";
+export class FormioResources {
+    auth;
+    resources = {};
+    error;
+    onError;
+    constructor(auth) {
+        this.auth = auth;
+        this.error = new EventEmitter();
+        this.onError = this.error;
+        this.resources = {
+            currentUser: {
+                resourceLoaded: this.auth.userReady
+            }
+        };
+    }
+    static ɵfac = function FormioResources_Factory(t) { return new (t || FormioResources)(i0.ɵɵinject(i1.FormioAuthService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FormioResources, factory: FormioResources.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormioResources, [{
+        type: Injectable
+    }], () => [{ type: i1.FormioAuthService }], null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb3VyY2VzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLWZvcm1pby9yZXNvdXJjZS9zcmMvcmVzb3VyY2VzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7OztBQVF6RCxNQUFNLE9BQU8sZUFBZTtJQUtqQjtJQUpULFNBQVMsR0FBc0IsRUFBRSxDQUFDO0lBQ2xDLEtBQUssQ0FBb0I7SUFDekIsT0FBTyxDQUFvQjtJQUMzQixZQUNTLElBQXdCO1FBQXhCLFNBQUksR0FBSixJQUFJLENBQW9CO1FBRS9CLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxZQUFZLEVBQUUsQ0FBQztRQUNoQyxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUM7UUFDMUIsSUFBSSxDQUFDLFNBQVMsR0FBRztZQUNmLFdBQVcsRUFBRTtnQkFDWCxjQUFjLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTO2FBQ3BDO1NBQ0YsQ0FBQztJQUNKLENBQUM7eUVBZFUsZUFBZTtnRUFBZixlQUFlLFdBQWYsZUFBZTs7aUZBQWYsZUFBZTtjQUQzQixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgRXZlbnRFbWl0dGVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGb3JtaW9BdXRoU2VydmljZSB9IGZyb20gJ0Bmb3JtaW8vYW5ndWxhci9hdXRoJztcblxuZXhwb3J0IGludGVyZmFjZSBGb3JtaW9SZXNvdXJjZU1hcCB7XG4gIFtuYW1lOiBzdHJpbmddOiBhbnk7XG59XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBGb3JtaW9SZXNvdXJjZXMge1xuICByZXNvdXJjZXM6IEZvcm1pb1Jlc291cmNlTWFwID0ge307XG4gIGVycm9yOiBFdmVudEVtaXR0ZXI8YW55PjtcbiAgb25FcnJvcjogRXZlbnRFbWl0dGVyPGFueT47XG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBhdXRoPzogRm9ybWlvQXV0aFNlcnZpY2VcbiAgKSB7XG4gICAgdGhpcy5lcnJvciA9IG5ldyBFdmVudEVtaXR0ZXIoKTtcbiAgICB0aGlzLm9uRXJyb3IgPSB0aGlzLmVycm9yO1xuICAgIHRoaXMucmVzb3VyY2VzID0ge1xuICAgICAgY3VycmVudFVzZXI6IHtcbiAgICAgICAgcmVzb3VyY2VMb2FkZWQ6IHRoaXMuYXV0aC51c2VyUmVhZHlcbiAgICAgIH1cbiAgICB9O1xuICB9XG59XG4iXX0=

package/dist/angular-formio/esm2022/resource/view/view.component.mjs

@@ -0,0 +1,30 @@
+import { Component } from '@angular/core';
+import { Formio } from '@formio/js';
+import * as i0 from "@angular/core";
+import * as i1 from "../resource.service";
+import * as i2 from "../resource.config";
+import * as i3 from "@formio/angular";
+export class FormioResourceViewComponent {
+    service;
+    config;
+    constructor(service, config) {
+        this.service = service;
+        this.config = config;
+    }
+    submission = { data: {} };
+    ngOnDestroy() {
+        Formio.clearCache();
+    }
+    static ɵfac = function FormioResourceViewComponent_Factory(t) { return new (t || FormioResourceViewComponent)(i0.ɵɵdirectiveInject(i1.FormioResourceService), i0.ɵɵdirectiveInject(i2.FormioResourceConfig)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: FormioResourceViewComponent, selectors: [["ng-component"]], decls: 1, vars: 4, consts: [[3, "form", "submission", "hideComponents", "readOnly"]], template: function FormioResourceViewComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelement(0, "formio", 0);
+        } if (rf & 2) {
+            i0.ɵɵproperty("form", ctx.service.form)("submission", ctx.service.resource)("hideComponents", ctx.config.parents)("readOnly", true);
+        } }, dependencies: [i3.FormioComponent], encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormioResourceViewComponent, [{
+        type: Component,
+        args: [{ template: "<formio\n  [form]=\"service.form\"\n  [submission]=\"service.resource\"\n  [hideComponents]=\"config.parents\"\n  [readOnly]=\"true\"\n></formio>\n" }]
+    }], () => [{ type: i1.FormioResourceService }, { type: i2.FormioResourceConfig }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(FormioResourceViewComponent, { className: "FormioResourceViewComponent" }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlldy5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLWZvcm1pby9yZXNvdXJjZS9zcmMvdmlldy92aWV3LmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItZm9ybWlvL3Jlc291cmNlL3NyYy92aWV3L3ZpZXcuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBWSxNQUFNLGVBQWUsQ0FBQztBQUduRCxPQUFPLEVBQUMsTUFBTSxFQUFDLE1BQU0sWUFBWSxDQUFDOzs7OztBQUtsQyxNQUFNLE9BQU8sMkJBQTJCO0lBRTdCO0lBQ0E7SUFGVCxZQUNTLE9BQThCLEVBQzlCLE1BQTRCO1FBRDVCLFlBQU8sR0FBUCxPQUFPLENBQXVCO1FBQzlCLFdBQU0sR0FBTixNQUFNLENBQXNCO0lBQ2xDLENBQUM7SUFDRyxVQUFVLEdBQUcsRUFBQyxJQUFJLEVBQUUsRUFBRSxFQUFDLENBQUM7SUFFL0IsV0FBVztRQUNULE1BQU0sQ0FBQyxVQUFVLEVBQUUsQ0FBQztJQUN0QixDQUFDO3FGQVRVLDJCQUEyQjs2REFBM0IsMkJBQTJCO1lDUnhDLDRCQUtVOztZQURSLEFBREEsQUFEQSxBQURBLHVDQUFxQixvQ0FDVSxzQ0FDRSxrQkFDaEI7OztpRkRJTiwyQkFBMkI7Y0FIdkMsU0FBUzs7O2tGQUdHLDJCQUEyQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7Q29tcG9uZW50LCBPbkRlc3Ryb3l9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRm9ybWlvUmVzb3VyY2VTZXJ2aWNlIH0gZnJvbSAnLi4vcmVzb3VyY2Uuc2VydmljZSc7XG5pbXBvcnQgeyBGb3JtaW9SZXNvdXJjZUNvbmZpZyB9IGZyb20gJy4uL3Jlc291cmNlLmNvbmZpZyc7XG5pbXBvcnQge0Zvcm1pb30gZnJvbSAnQGZvcm1pby9qcyc7XG5cbkBDb21wb25lbnQoe1xuICB0ZW1wbGF0ZVVybDogJy4vdmlldy5jb21wb25lbnQuaHRtbCdcbn0pXG5leHBvcnQgY2xhc3MgRm9ybWlvUmVzb3VyY2VWaWV3Q29tcG9uZW50IGltcGxlbWVudHMgT25EZXN0cm95e1xuICBjb25zdHJ1Y3RvcihcbiAgICBwdWJsaWMgc2VydmljZTogRm9ybWlvUmVzb3VyY2VTZXJ2aWNlLFxuICAgIHB1YmxpYyBjb25maWc6IEZvcm1pb1Jlc291cmNlQ29uZmlnXG4gICkge31cbiAgcHVibGljIHN1Ym1pc3Npb24gPSB7ZGF0YToge319O1xuXG4gIG5nT25EZXN0cm95KCkge1xuICAgIEZvcm1pby5jbGVhckNhY2hlKCk7XG4gIH1cbn1cbiIsIjxmb3JtaW9cbiAgW2Zvcm1dPVwic2VydmljZS5mb3JtXCJcbiAgW3N1Ym1pc3Npb25dPVwic2VydmljZS5yZXNvdXJjZVwiXG4gIFtoaWRlQ29tcG9uZW50c109XCJjb25maWcucGFyZW50c1wiXG4gIFtyZWFkT25seV09XCJ0cnVlXCJcbj48L2Zvcm1pbz5cbiJdfQ==