@gravitee/ui-particles-angular 15.13.0-angular-20-f024970 → 15.13.0-test-npm-publish-aaef706

package/esm2022/lib/gio-form-headers/gio-form-headers.harness.mjs

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ComponentHarness, HarnessPredicate, parallel } from '@angular/cdk/testing';
+import { MatButtonHarness } from '@angular/material/button/testing';
+import { MatInputHarness } from '@angular/material/input/testing';
+import { MatAutocompleteHarness } from '@angular/material/autocomplete/testing';
+export class GioFormHeadersHarness extends ComponentHarness {
+    constructor() {
+        super(...arguments);
+        this.getHeaderRowsElement = this.locatorForAll('tr.gio-form-headers__table__header-row');
+        this.getHeaderRowInputKey = (rowIndex) => this.locatorFor(MatInputHarness.with({ ancestor: `[ng-reflect-name="${rowIndex}"]`, selector: '[formControlName=key]' }));
+        this.getHeaderRowInputKeyAutocomplete = (rowIndex) => this.locatorFor(MatAutocompleteHarness.with({ ancestor: `tr[ng-reflect-name="${rowIndex}"]` }));
+        this.getHeaderRowInputValue = (rowIndex) => this.locatorFor(MatInputHarness.with({ ancestor: `tr[ng-reflect-name="${rowIndex}"]`, selector: '[formControlName=value]' }));
+        this.getHeaderRowRemoveButton = (rowIndex) => this.locatorForOptional(MatButtonHarness.with({ ancestor: `tr[ng-reflect-name="${rowIndex}"]`, selector: '[aria-label="Delete"]' }));
+    }
+    static { this.hostSelector = 'gio-form-headers'; }
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `GioFormColorInputHarness` that meets
+     * certain criteria.
+     *
+     * @param options Options for filtering which input instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(GioFormHeadersHarness, options);
+    }
+    async getHeaderRows() {
+        const rows = await this.getHeaderRowsElement();
+        return Promise.all(rows.map(async (_, rowIndex) => ({
+            keyInput: await this.getHeaderRowInputKey(rowIndex)(),
+            keyAutocomplete: await this.getHeaderRowInputKeyAutocomplete(rowIndex)(),
+            valueInput: await this.getHeaderRowInputValue(rowIndex)(),
+            removeButton: await this.getHeaderRowRemoveButton(rowIndex)(),
+        })));
+    }
+    async getLastHeaderRow() {
+        const rows = await this.getHeaderRowsElement();
+        return {
+            keyInput: await this.getHeaderRowInputKey(rows.length - 1)(),
+            valueInput: await this.getHeaderRowInputValue(rows.length - 1)(),
+        };
+    }
+    async addHeader({ key, value }) {
+        const { keyInput, valueInput } = await this.getLastHeaderRow();
+        await keyInput.setValue(key);
+        await valueInput.setValue(value);
+    }
+    async isDisabled() {
+        return (await this.host()).hasClass('disabled');
+    }
+    async getValue() {
+        const rows = await this.getHeaderRows();
+        if (!(await this.isDisabled())) {
+            // Remove last empty value
+            rows.pop();
+        }
+        return parallel(() => rows.map(async (r) => ({ key: await r.keyInput.getValue(), value: await r.valueInput.getValue() })));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gio-form-headers.harness.js","sourceRoot":"","sources":["../../../../../projects/ui-particles-angular/src/lib/gio-form-headers/gio-form-headers.harness.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (C) 2015 The Gravitee team (http://gravitee.io)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AsyncFactoryFn, BaseHarnessFilters, ComponentHarness, HarnessPredicate, parallel } from '@angular/cdk/testing';\nimport { MatButtonHarness } from '@angular/material/button/testing';\nimport { MatInputHarness } from '@angular/material/input/testing';\nimport { MatAutocompleteHarness } from '@angular/material/autocomplete/testing';\n\nexport class GioFormHeadersHarness extends ComponentHarness {\n  public static hostSelector = 'gio-form-headers';\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a `GioFormColorInputHarness` that meets\n   * certain criteria.\n   *\n   * @param options Options for filtering which input instances are considered a match.\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  public static with(options: BaseHarnessFilters = {}): HarnessPredicate<GioFormHeadersHarness> {\n    return new HarnessPredicate(GioFormHeadersHarness, options);\n  }\n\n  private getHeaderRowsElement = this.locatorForAll('tr.gio-form-headers__table__header-row');\n\n  private getHeaderRowInputKey = (rowIndex: number): AsyncFactoryFn<MatInputHarness> =>\n    this.locatorFor(MatInputHarness.with({ ancestor: `[ng-reflect-name=\"${rowIndex}\"]`, selector: '[formControlName=key]' }));\n\n  private getHeaderRowInputKeyAutocomplete = (rowIndex: number): AsyncFactoryFn<MatAutocompleteHarness> =>\n    this.locatorFor(MatAutocompleteHarness.with({ ancestor: `tr[ng-reflect-name=\"${rowIndex}\"]` }));\n\n  private getHeaderRowInputValue = (rowIndex: number): AsyncFactoryFn<MatInputHarness> =>\n    this.locatorFor(MatInputHarness.with({ ancestor: `tr[ng-reflect-name=\"${rowIndex}\"]`, selector: '[formControlName=value]' }));\n\n  private getHeaderRowRemoveButton = (rowIndex: number): AsyncFactoryFn<MatButtonHarness | null> =>\n    this.locatorForOptional(MatButtonHarness.with({ ancestor: `tr[ng-reflect-name=\"${rowIndex}\"]`, selector: '[aria-label=\"Delete\"]' }));\n\n  public async getHeaderRows(): Promise<\n    {\n      keyInput: MatInputHarness;\n      keyAutocomplete: MatAutocompleteHarness;\n      valueInput: MatInputHarness;\n      removeButton: MatButtonHarness | null;\n    }[]\n  > {\n    const rows = await this.getHeaderRowsElement();\n\n    return Promise.all(\n      rows.map(async (_, rowIndex) => ({\n        keyInput: await this.getHeaderRowInputKey(rowIndex)(),\n        keyAutocomplete: await this.getHeaderRowInputKeyAutocomplete(rowIndex)(),\n        valueInput: await this.getHeaderRowInputValue(rowIndex)(),\n        removeButton: await this.getHeaderRowRemoveButton(rowIndex)(),\n      })),\n    );\n  }\n\n  public async getLastHeaderRow(): Promise<{ keyInput: MatInputHarness; valueInput: MatInputHarness }> {\n    const rows = await this.getHeaderRowsElement();\n\n    return {\n      keyInput: await this.getHeaderRowInputKey(rows.length - 1)(),\n      valueInput: await this.getHeaderRowInputValue(rows.length - 1)(),\n    };\n  }\n\n  public async addHeader({ key, value }: { key: string; value: string }): Promise<void> {\n    const { keyInput, valueInput } = await this.getLastHeaderRow();\n\n    await keyInput.setValue(key);\n    await valueInput.setValue(value);\n  }\n\n  public async isDisabled(): Promise<boolean> {\n    return (await this.host()).hasClass('disabled');\n  }\n\n  public async getValue(): Promise<{ key: string; value: string }[]> {\n    const rows = await this.getHeaderRows();\n\n    if (!(await this.isDisabled())) {\n      // Remove last empty value\n      rows.pop();\n    }\n\n    return parallel(() => rows.map(async r => ({ key: await r.keyInput.getValue(), value: await r.valueInput.getValue() })));\n  }\n}\n"]}

package/esm2022/lib/gio-form-headers/gio-form-headers.module.mjs

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
+import { MatOptionModule } from '@angular/material/core';
+import { GioIconsModule } from '../gio-icons/gio-icons.module';
+import { GioElAssistantComponent, GioElPromptComponent } from '../gio-el';
+import { GioPopoverComponent, PopoverTriggerDirective } from '../gio-popover';
+import { GioFormHeadersComponent } from './gio-form-headers.component';
+import { GioFormHeadersLabelComponent } from './gio-form-headers-label.component';
+import * as i0 from "@angular/core";
+export class GioFormHeadersModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GioFormHeadersModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.4", ngImport: i0, type: GioFormHeadersModule, declarations: [GioFormHeadersComponent, GioFormHeadersLabelComponent], imports: [CommonModule,
+            MatInputModule,
+            MatFormFieldModule,
+            ReactiveFormsModule,
+            GioIconsModule,
+            MatButtonModule,
+            MatAutocompleteModule,
+            MatOptionModule,
+            GioElPromptComponent,
+            GioPopoverComponent,
+            PopoverTriggerDirective,
+            GioElAssistantComponent], exports: [GioFormHeadersComponent, GioFormHeadersLabelComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GioFormHeadersModule, imports: [CommonModule,
+            MatInputModule,
+            MatFormFieldModule,
+            ReactiveFormsModule,
+            GioIconsModule,
+            MatButtonModule,
+            MatAutocompleteModule,
+            MatOptionModule,
+            GioElPromptComponent,
+            GioPopoverComponent,
+            GioElAssistantComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GioFormHeadersModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        MatInputModule,
+                        MatFormFieldModule,
+                        ReactiveFormsModule,
+                        GioIconsModule,
+                        MatButtonModule,
+                        MatAutocompleteModule,
+                        MatOptionModule,
+                        GioElPromptComponent,
+                        GioPopoverComponent,
+                        PopoverTriggerDirective,
+                        GioElAssistantComponent,
+                    ],
+                    declarations: [GioFormHeadersComponent, GioFormHeadersLabelComponent],
+                    exports: [GioFormHeadersComponent, GioFormHeadersLabelComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/gio-form-json-schema/gio-form-json-schema.component.mjs

@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2023 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ChangeDetectionStrategy, Component, EventEmitter, Host, HostBinding, Input, Optional, Output, } from '@angular/core';
+import { UntypedFormGroup } from '@angular/forms';
+import { cloneDeep, isEmpty, isEqual, isObject, set } from 'lodash';
+import { debounceTime, delay, distinctUntilChanged, filter, map, startWith, take, takeUntil, tap } from 'rxjs/operators';
+import { merge, ReplaySubject, Subject } from 'rxjs';
+import { GIO_FORM_FOCUS_INVALID_IGNORE_SELECTOR } from '../gio-form-focus-first-invalid/gio-form-focus-first-invalid-ignore.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "./gio-formly-json-schema.service";
+import * as i2 from "@angular/cdk/a11y";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/common";
+import * as i5 from "@ngx-formly/core";
+export class GioFormJsonSchemaComponent {
+    static isDisplayable(jsonSchema) {
+        const properties = ['properties', 'oneOf', 'anyOf', 'allOf', '$ref', 'items'];
+        return isObject(jsonSchema) && properties.some(property => !isEmpty(jsonSchema[property]));
+    }
+    constructor(gioFormlyJsonSchema, elRef, fm, changeDetectorRef, ngControl) {
+        this.gioFormlyJsonSchema = gioFormlyJsonSchema;
+        this.elRef = elRef;
+        this.fm = fm;
+        this.changeDetectorRef = changeDetectorRef;
+        this.ngControl = ngControl;
+        this.unsubscribe$ = new Subject();
+        this.gioFormFocusInvalidIgnore = true;
+        this.formGroup = new UntypedFormGroup({});
+        this.options = {};
+        // When true the form is ready and control status are up-to-date
+        // Useful to know when initial control status can be used
+        this.ready = new EventEmitter();
+        this.isReady = false;
+        this.model = {};
+        this.fields = [];
+        this.isDisabled = false;
+        this._onChange = () => ({});
+        this._onTouched = () => ({});
+        this.touched = false;
+        this.isValid$ = new ReplaySubject(1); // Wait JsonSchema to be loaded to check if it's valid
+        this.stateChanges$ = new Subject();
+        if (ngControl) {
+            // Setting the value accessor directly (instead of using
+            // the providers `NG_VALUE_ACCESSOR`) to avoid running into a circular import.
+            ngControl.valueAccessor = this;
+        }
+        // When the user interact with the form, mark it as touched
+        fm.monitor(elRef.nativeElement, true)
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe(() => {
+            if (this.isDisabled) {
+                return;
+            }
+            this._onTouched();
+            this.touched = true;
+        });
+    }
+    ngOnChanges(changes) {
+        if (changes.jsonSchema) {
+            this.isReady = false;
+            this.ready.next(false);
+        }
+        if (changes.jsonSchema || changes.context) {
+            if (!isEmpty(this.jsonSchema)) {
+                this.fields = [this.gioFormlyJsonSchema.toFormlyFieldConfig(this.jsonSchema, this.context)];
+            }
+        }
+    }
+    ngOnInit() {
+        // When the parent form is touched, mark all the sub formGroup as touched if not already touched
+        const parentControl = this.ngControl?.control?.parent;
+        parentControl?.statusChanges
+            ?.pipe(map(() => parentControl?.touched), filter(touched => touched === true), distinctUntilChanged(), takeUntil(this.unsubscribe$))
+            .subscribe(() => {
+            if (this.isDisabled) {
+                return;
+            }
+            this.formGroup.markAllAsTouched();
+            this.stateChanges$.next();
+        });
+        // Add async validator to the parent
+        this.ngControl?.control?.addAsyncValidators(() => {
+            return this.isValid$.pipe(take(1), map(isValid => (isValid ? null : { invalid: true })), takeUntil(this.unsubscribe$));
+        });
+        // Sync control value with default value (without emit event) as long as the component is not ready
+        // When formly is initialised, it emits several values as it builds up step by step.
+        this.formGroup.valueChanges
+            .pipe(distinctUntilChanged(isEqual), tap(value => {
+            this.ngControl?.control?.reset(value, { emitEvent: false });
+        }), takeUntil(this.ready), takeUntil(this.unsubscribe$))
+            .subscribe();
+        // Avoid ExpressionChangedAfterItHasBeenCheckedError on project
+        this.changeDetectorRef.markForCheck();
+        this.changeDetectorRef.detectChanges();
+        // Subscribe to state changes to manage touches, status and value
+        this.stateChanges$
+            .pipe(tap(() => {
+            const { status, value, touched } = this.formGroup;
+            if (this.isDisabled) {
+                return;
+            }
+            if (status === 'VALID') {
+                this.isValid$.next(true);
+            }
+            if (status === 'INVALID') {
+                this.isValid$.next(false);
+            }
+            if (touched && !this.touched) {
+                this._onTouched();
+                this.touched = true;
+            }
+            if (this.touched) {
+                this._onChange(value);
+            }
+        }), delay(0), 
+        // Keep at the end
+        takeUntil(this.unsubscribe$))
+            .subscribe(() => {
+            this.changeDetectorRef.markForCheck();
+            this.changeDetectorRef.detectChanges();
+            this.ngControl?.control?.updateValueAndValidity({
+                emitEvent: false,
+            });
+            // After the first state change, the form is ready
+            if (!this.isReady) {
+                this.isReady = true;
+                this.ready.emit(true);
+            }
+        });
+    }
+    ngAfterViewInit() {
+        // Group all valueChanges events emit by formly in a single one
+        merge(this.formGroup.statusChanges, this.formGroup.valueChanges)
+            .pipe(
+        // Force fist stateChanges$
+        startWith({}), debounceTime(100), takeUntil(this.unsubscribe$))
+            .subscribe(() => {
+            this.stateChanges$.next();
+        });
+    }
+    ngOnDestroy() {
+        this.unsubscribe$.next();
+        this.unsubscribe$.unsubscribe();
+        this.fm.stopMonitoring(this.elRef.nativeElement);
+    }
+    // From ControlValueAccessor
+    writeValue(value) {
+        this.model = cloneDeep(value) ?? {};
+    }
+    // From ControlValueAccessor
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    // From ControlValueAccessor
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    // From ControlValueAccessor
+    setDisabledState(isDisabled) {
+        if (this.isDisabled === isDisabled) {
+            return;
+        }
+        this.isDisabled = isDisabled;
+        set(this.options, 'formState.parentDisabled', isDisabled);
+        setTimeout(() => {
+            isDisabled ? this.formGroup.disable({ emitEvent: false }) : this.formGroup.enable({ emitEvent: false });
+            this.changeDetectorRef.markForCheck();
+            this.changeDetectorRef.detectChanges();
+            this.stateChanges$.next();
+        }, 0);
+        this.stateChanges$.next();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GioFormJsonSchemaComponent, deps: [{ token: i1.GioFormlyJsonSchemaService }, { token: i0.ElementRef }, { token: i2.FocusMonitor }, { token: i0.ChangeDetectorRef }, { token: i3.NgControl, host: true, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.4", type: GioFormJsonSchemaComponent, isStandalone: false, selector: "gio-form-json-schema", inputs: { jsonSchema: "jsonSchema", context: "context", options: "options" }, outputs: { ready: "ready" }, host: { properties: { "attr.gioFormFocusInvalidIgnore": "this.gioFormFocusInvalidIgnore" } }, usesOnChanges: true, ngImport: i0, template: `<formly-form *ngIf="formGroup" [fields]="fields" [options]="options" [form]="formGroup" [model]="model"></formly-form>`, isInline: true, styles: [""], dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i5.FormlyForm, selector: "formly-form", inputs: ["form", "model", "fields", "options"], outputs: ["modelChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GioFormJsonSchemaComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'gio-form-json-schema', template: `<formly-form *ngIf="formGroup" [fields]="fields" [options]="options" [form]="formGroup" [model]="model"></formly-form>`, changeDetection: ChangeDetectionStrategy.OnPush, standalone: false }]
+        }], ctorParameters: () => [{ type: i1.GioFormlyJsonSchemaService }, { type: i0.ElementRef }, { type: i2.FocusMonitor }, { type: i0.ChangeDetectorRef }, { type: i3.NgControl, decorators: [{
+                    type: Host
+                }, {
+                    type: Optional
+                }] }], propDecorators: { gioFormFocusInvalidIgnore: [{
+                type: HostBinding,
+                args: [`attr.${GIO_FORM_FOCUS_INVALID_IGNORE_SELECTOR}`]
+            }], jsonSchema: [{
+                type: Input,
+                args: [{ required: true }]
+            }], context: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], ready: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gio-form-json-schema.component.js","sourceRoot":"","sources":["../../../../../projects/ui-particles-angular/src/lib/gio-form-json-schema/gio-form-json-schema.component.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (C) 2023 The Gravitee team (http://gravitee.io)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Host,\n  HostBinding,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  SimpleChanges,\n} from '@angular/core';\nimport { ControlValueAccessor, UntypedFormGroup, NgControl } from '@angular/forms';\nimport { FormlyFieldConfig, FormlyFormOptions } from '@ngx-formly/core';\nimport { cloneDeep, isEmpty, isEqual, isObject, set } from 'lodash';\nimport { debounceTime, delay, distinctUntilChanged, filter, map, startWith, take, takeUntil, tap } from 'rxjs/operators';\nimport { merge, ReplaySubject, Subject } from 'rxjs';\nimport { FocusMonitor } from '@angular/cdk/a11y';\n\nimport { GIO_FORM_FOCUS_INVALID_IGNORE_SELECTOR } from '../gio-form-focus-first-invalid/gio-form-focus-first-invalid-ignore.directive';\n\nimport { GioJsonSchema } from './model/GioJsonSchema';\nimport { GioFormlyJsonSchemaService } from './gio-formly-json-schema.service';\nimport { GioJsonSchemaContext } from './model/GioJsonSchemaContext';\n\n@Component({\n  selector: 'gio-form-json-schema',\n  template: `<formly-form *ngIf=\"formGroup\" [fields]=\"fields\" [options]=\"options\" [form]=\"formGroup\" [model]=\"model\"></formly-form>`,\n  styleUrls: ['./gio-form-json-schema.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: false,\n})\nexport class GioFormJsonSchemaComponent implements ControlValueAccessor, OnChanges, OnInit, AfterViewInit, OnDestroy {\n  public static isDisplayable(jsonSchema: GioJsonSchema): boolean {\n    const properties = ['properties', 'oneOf', 'anyOf', 'allOf', '$ref', 'items'] as const;\n\n    return isObject(jsonSchema) && properties.some(property => !isEmpty(jsonSchema[property]));\n  }\n  private unsubscribe$: Subject<void> = new Subject<void>();\n\n  @HostBinding(`attr.${GIO_FORM_FOCUS_INVALID_IGNORE_SELECTOR}`)\n  private gioFormFocusInvalidIgnore = true;\n\n  @Input({ required: true })\n  public jsonSchema!: GioJsonSchema;\n\n  @Input()\n  public context?: GioJsonSchemaContext;\n\n  public formGroup: UntypedFormGroup = new UntypedFormGroup({});\n\n  @Input()\n  public options: FormlyFormOptions = {};\n\n  // When true the form is ready and control status are up-to-date\n  // Useful to know when initial control status can be used\n  @Output()\n  public ready = new EventEmitter<boolean>();\n\n  private isReady = false;\n\n  public model: unknown = {};\n\n  public fields: FormlyFieldConfig[] = [];\n\n  public isDisabled = false;\n\n  public _onChange: (value: unknown | null) => void = () => ({});\n\n  public _onTouched: () => void = () => ({});\n\n  private touched = false;\n\n  private isValid$ = new ReplaySubject(1); // Wait JsonSchema to be loaded to check if it's valid\n\n  private stateChanges$ = new Subject<void>();\n\n  constructor(\n    private readonly gioFormlyJsonSchema: GioFormlyJsonSchemaService,\n    private readonly elRef: ElementRef,\n    private readonly fm: FocusMonitor,\n    private readonly changeDetectorRef: ChangeDetectorRef,\n    @Host() @Optional() public readonly ngControl?: NgControl,\n  ) {\n    if (ngControl) {\n      // Setting the value accessor directly (instead of using\n      // the providers `NG_VALUE_ACCESSOR`) to avoid running into a circular import.\n      ngControl.valueAccessor = this;\n    }\n\n    // When the user interact with the form, mark it as touched\n    fm.monitor(elRef.nativeElement, true)\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe(() => {\n        if (this.isDisabled) {\n          return;\n        }\n        this._onTouched();\n        this.touched = true;\n      });\n  }\n\n  public ngOnChanges(changes: SimpleChanges) {\n    if (changes.jsonSchema) {\n      this.isReady = false;\n      this.ready.next(false);\n    }\n\n    if (changes.jsonSchema || changes.context) {\n      if (!isEmpty(this.jsonSchema)) {\n        this.fields = [this.gioFormlyJsonSchema.toFormlyFieldConfig(this.jsonSchema, this.context)];\n      }\n    }\n  }\n\n  public ngOnInit(): void {\n    // When the parent form is touched, mark all the sub formGroup as touched if not already touched\n    const parentControl = this.ngControl?.control?.parent;\n    parentControl?.statusChanges\n      ?.pipe(\n        map(() => parentControl?.touched),\n        filter(touched => touched === true),\n        distinctUntilChanged(),\n        takeUntil(this.unsubscribe$),\n      )\n      .subscribe(() => {\n        if (this.isDisabled) {\n          return;\n        }\n        this.formGroup.markAllAsTouched();\n        this.stateChanges$.next();\n      });\n    // Add async validator to the parent\n    this.ngControl?.control?.addAsyncValidators(() => {\n      return this.isValid$.pipe(\n        take(1),\n        map(isValid => (isValid ? null : { invalid: true })),\n        takeUntil(this.unsubscribe$),\n      );\n    });\n\n    // Sync control value with default value (without emit event) as long as the component is not ready\n    // When formly is initialised, it emits several values as it builds up step by step.\n    this.formGroup.valueChanges\n      .pipe(\n        distinctUntilChanged(isEqual),\n        tap(value => {\n          this.ngControl?.control?.reset(value, { emitEvent: false });\n        }),\n        takeUntil(this.ready),\n        takeUntil(this.unsubscribe$),\n      )\n      .subscribe();\n\n    // Avoid ExpressionChangedAfterItHasBeenCheckedError on project\n    this.changeDetectorRef.markForCheck();\n    this.changeDetectorRef.detectChanges();\n\n    // Subscribe to state changes to manage touches, status and value\n    this.stateChanges$\n      .pipe(\n        tap(() => {\n          const { status, value, touched } = this.formGroup;\n          if (this.isDisabled) {\n            return;\n          }\n\n          if (status === 'VALID') {\n            this.isValid$.next(true);\n          }\n          if (status === 'INVALID') {\n            this.isValid$.next(false);\n          }\n\n          if (touched && !this.touched) {\n            this._onTouched();\n            this.touched = true;\n          }\n\n          if (this.touched) {\n            this._onChange(value);\n          }\n        }),\n        delay(0),\n        // Keep at the end\n        takeUntil(this.unsubscribe$),\n      )\n      .subscribe(() => {\n        this.changeDetectorRef.markForCheck();\n        this.changeDetectorRef.detectChanges();\n        this.ngControl?.control?.updateValueAndValidity({\n          emitEvent: false,\n        });\n\n        // After the first state change, the form is ready\n        if (!this.isReady) {\n          this.isReady = true;\n          this.ready.emit(true);\n        }\n      });\n  }\n\n  public ngAfterViewInit(): void {\n    // Group all valueChanges events emit by formly in a single one\n    merge(this.formGroup.statusChanges, this.formGroup.valueChanges)\n      .pipe(\n        // Force fist stateChanges$\n        startWith({}),\n        debounceTime(100),\n        takeUntil(this.unsubscribe$),\n      )\n      .subscribe(() => {\n        this.stateChanges$.next();\n      });\n  }\n\n  public ngOnDestroy() {\n    this.unsubscribe$.next();\n    this.unsubscribe$.unsubscribe();\n    this.fm.stopMonitoring(this.elRef.nativeElement);\n  }\n\n  // From ControlValueAccessor\n  public writeValue(value: unknown): void {\n    this.model = cloneDeep(value) ?? {};\n  }\n\n  // From ControlValueAccessor\n  public registerOnChange(fn: (value: unknown | null) => void): void {\n    this._onChange = fn;\n  }\n\n  // From ControlValueAccessor\n  public registerOnTouched(fn: () => void): void {\n    this._onTouched = fn;\n  }\n\n  // From ControlValueAccessor\n  public setDisabledState?(isDisabled: boolean): void {\n    if (this.isDisabled === isDisabled) {\n      return;\n    }\n\n    this.isDisabled = isDisabled;\n\n    set(this.options, 'formState.parentDisabled', isDisabled);\n    setTimeout(() => {\n      isDisabled ? this.formGroup.disable({ emitEvent: false }) : this.formGroup.enable({ emitEvent: false });\n      this.changeDetectorRef.markForCheck();\n      this.changeDetectorRef.detectChanges();\n      this.stateChanges$.next();\n    }, 0);\n\n    this.stateChanges$.next();\n  }\n}\n"]}