commons-shared-web-ui 0.0.53 → 0.0.54

package/src/lib/modules/form-field-configuration/components/form-field-configuration/form-field-configuration.component.ts

@@ -1,92 +0,0 @@
-import {
-  Component,
-  ChangeDetectionStrategy,
-  Input,
-  OnChanges,
-  SimpleChanges,
-  inject,
-} from '@angular/core';
-import { FormSchema } from '../../../smart-form/models/form-schema.model';
-import { FieldConfigurationService } from '../../services/field-configuration.service';
-import { FieldEventPayload } from '../config-section-node/config-section-node.component';
-
-/**
- * Form Field Configuration
- * ------------------------
- * Renders a compact tree of a form schema's sections and fields, each with a
- * **visibility** toggle and a **mandatory** control. Intended to be embedded
- * inside a `cc-confirmation-modal` on a host page ("Configure fields").
- *
- * Pass a `FormSchema` via `[schema]`. The input is deep-cloned, so it is never
- * mutated. When the user confirms, call `getUpdatedSchema()` to read back the
- * modified schema (visible/isEnabled/disabled and required flags updated).
- *
- * Fields/sections carrying `lockVisibility: true` cannot be hidden, and
- * `lockMandatory: true` freezes their required state.
- *
- * @example
- * ```html
- * <cc-confirmation-modal [isOpen]="open" (confirm)="save()" (cancel)="open = false">
- *   <lib-form-field-configuration #cfg [schema]="schema" [translate]="translateFn" />
- * </cc-confirmation-modal>
- * ```
- * ```ts
- * @ViewChild('cfg') cfg!: FormFieldConfigurationComponent;
- * save() { this.updatedSchema = this.cfg.getUpdatedSchema(); }
- * ```
- */
-@Component({
-  selector: 'lib-form-field-configuration',
-  standalone: false,
-  providers: [FieldConfigurationService],
-  templateUrl: './form-field-configuration.component.html',
-  styleUrls: ['./form-field-configuration.component.scss'],
-  changeDetection: ChangeDetectionStrategy.OnPush,
-})
-export class FormFieldConfigurationComponent implements OnChanges {
-  /** The form schema to configure. Deep-cloned internally; never mutated. */
-  @Input({ required: true }) schema!: FormSchema;
-
-  /** Optional label translator, e.g. an ngx-translate `instant` function. */
-  @Input() translate?: (key: string) => string;
-
-  /** Show the "Visible / Mandatory (only if visible)" legend row. Default true. */
-  @Input() showLegend = true;
-
-  protected readonly store = inject(FieldConfigurationService);
-
-  ngOnChanges(changes: SimpleChanges): void {
-    if (changes['schema'] && this.schema) {
-      this.store.loadSchema(this.schema);
-    }
-  }
-
-  /**
-   * Returns a fresh, modified copy of the schema with the current
-   * visibility/mandatory selections applied. Returns null if no schema loaded.
-   */
-  getUpdatedSchema(): FormSchema | null {
-    return this.store.buildUpdatedSchema();
-  }
-
-  // ── Event wiring (prefix top-level section index → store) ───────
-  onToggleVisible(sectionIndex: number, subPath: number[]): void {
-    this.store.toggleSectionVisible([sectionIndex, ...subPath]);
-  }
-
-  onToggleExpanded(sectionIndex: number, subPath: number[]): void {
-    this.store.toggleSectionExpanded([sectionIndex, ...subPath]);
-  }
-
-  onFieldToggleVisible(sectionIndex: number, payload: FieldEventPayload): void {
-    this.store.toggleFieldVisible([sectionIndex, ...payload.sectionPath], payload.fieldIndex);
-  }
-
-  onFieldToggleMandatory(sectionIndex: number, payload: FieldEventPayload): void {
-    this.store.toggleFieldMandatory([sectionIndex, ...payload.sectionPath], payload.fieldIndex);
-  }
-
-  trackByIndex(index: number): number {
-    return index;
-  }
-}

package/src/lib/modules/form-field-configuration/form-field-configuration.module.ts

@@ -1,23 +0,0 @@
-import { NgModule } from '@angular/core';
-import { CommonModule } from '@angular/common';
-
-import { FormFieldConfigurationComponent } from './components/form-field-configuration/form-field-configuration.component';
-import { ConfigSectionNodeComponent } from './components/config-section-node/config-section-node.component';
-import { ConfigFieldNodeComponent } from './components/config-field-node/config-field-node.component';
-
-const COMPONENTS = [
-  FormFieldConfigurationComponent,
-  ConfigSectionNodeComponent,
-  ConfigFieldNodeComponent,
-];
-
-@NgModule({
-  declarations: [...COMPONENTS],
-  imports: [
-    CommonModule,
-  ],
-  exports: [
-    FormFieldConfigurationComponent,
-  ],
-})
-export class FormFieldConfigurationModule {}

package/src/lib/modules/form-field-configuration/index.ts

@@ -1,7 +0,0 @@
-export * from './form-field-configuration.module';
-export * from './components/form-field-configuration/form-field-configuration.component';
-export * from './components/config-section-node/config-section-node.component';
-export * from './components/config-field-node/config-field-node.component';
-export * from './models/field-configuration.models';
-export * from './services/field-configuration.service';
-export * from './services/config-schema-tree.service';

package/src/lib/modules/form-field-configuration/models/field-configuration.models.ts

@@ -1,62 +0,0 @@
-import { FieldConfig, SectionConfig } from '../../smart-form/models/form-schema.model';
-
-/**
- * A single editable field row in the configurator.
- * Wraps a leaf FieldConfig with visibility + mandatory state.
- *
- * `fieldConfig` is a live reference into the module's working (cloned) schema,
- * so writing the node state back onto it is all that's needed to produce the
- * updated schema — no fragile index re-matching required.
- */
-export interface ConfigFieldNode {
-  /** Live reference to the FieldConfig inside the working schema clone. */
-  fieldConfig: FieldConfig;
-  /** Display label (resolved through the optional translate fn at render time uses fieldConfig directly). */
-  label: string;
-  /** Raw field type (e.g. 'TEXT_INPUT', 'DROPDOWN'). */
-  type: string;
-  /** Whether the field is shown to end users. */
-  visible: boolean;
-  /** Whether the field is mandatory (required). Only meaningful when `visible` is true. */
-  mandatory: boolean;
-  /** When true, the visibility toggle is locked ON (cannot be hidden). */
-  lockVisibility: boolean;
-  /** When true, the mandatory control is locked (cannot be changed). */
-  lockMandatory: boolean;
-  /**
-   * Name of the field this one depends on, read from
-   * `optionConfig.dependencies.parentDataCode` (e.g. a `state` dropdown depends
-   * on `country`). When the parent is hidden, this field must be hidden too.
-   */
-  parentName?: string;
-  /**
-   * Derived: true when this field's dependency parent is currently hidden.
-   * While true the field is force-hidden and its visibility toggle is disabled —
-   * the user must show the parent field before this one can be shown.
-   */
-  visibilityLockedByParent: boolean;
-}
-
-/**
- * A section / group in the configurator tree. Sections can nest recursively.
- * A section with `fieldConfig === null` is a synthetic bundle of stray
- * top-level leaf fields and has no visibility toggle of its own.
- */
-export interface ConfigSectionNode {
-  /** Section label. */
-  label: string;
-  /** Live reference to the GROUP/SUBFIELDS FieldConfig, or null for a synthetic bundle / root. */
-  fieldConfig: FieldConfig | null;
-  /** Live reference to the backing SectionConfig, when present. */
-  sectionConfig: SectionConfig | null;
-  /** Whether the whole section is shown to end users. */
-  visible: boolean;
-  /** When true, the section visibility toggle is locked ON. */
-  lockVisibility: boolean;
-  /** Whether the section is expanded in the UI tree. */
-  expanded: boolean;
-  /** Leaf fields directly inside this section. */
-  fields: ConfigFieldNode[];
-  /** Recursively nested child sections. */
-  subsections: ConfigSectionNode[];
-}

package/src/lib/modules/form-field-configuration/services/config-schema-tree.service.ts

@@ -1,148 +0,0 @@
-import { Injectable } from '@angular/core';
-import {
-  FormSchema,
-  FieldConfig,
-} from '../../smart-form/models/form-schema.model';
-import {
-  ConfigSectionNode,
-  ConfigFieldNode,
-} from '../models/field-configuration.models';
-
-/**
- * Parses a FormSchema into a configurator tree (sections + fields, each carrying
- * visibility/mandatory state) and writes that tree back onto a schema.
- *
- * Nodes hold LIVE references to the FieldConfig objects inside the working schema
- * clone, so `applyTreeToSchema` simply walks the tree and assigns the node state
- * onto those references — there is no positional re-matching, which keeps it robust
- * against ROWs, nested groups, and mixed leaf/section children.
- */
-@Injectable({ providedIn: 'root' })
-export class ConfigSchemaTreeService {
-  // ── Parsing ─────────────────────────────────────────────────────────────────
-
-  /**
-   * Build the configurator section tree from a schema.
-   * The passed schema is treated as the working copy — nodes reference its objects.
-   */
-  parseSchema(schema: FormSchema): ConfigSectionNode[] {
-    const topChildren =
-      schema.formType === 'STEPPER'
-        ? (schema.stepperConfig?.children ?? []).filter(c => c.type === 'GROUP')
-        : schema.sectionConfig?.children ?? [];
-    return this._buildSections(topChildren);
-  }
-
-  /**
-   * Write the current tree state back onto the schema the nodes reference.
-   * Sets isEnabled/visible/disabled for visibility and required for mandatory.
-   * Hidden fields always emit required: false ("mandatory only if visible").
-   */
-  applyTreeToSchema(sections: ConfigSectionNode[]): void {
-    for (const section of sections) {
-      this._applySection(section);
-    }
-  }
-
-  // ── Private: parsing ──────────────────────────────────────────────────────────
-
-  private _buildSections(children: FieldConfig[]): ConfigSectionNode[] {
-    const sections: ConfigSectionNode[] = [];
-    let leafBundle: ConfigFieldNode[] = [];
-
-    for (const child of children) {
-      if (this._isSection(child)) {
-        if (leafBundle.length) {
-          sections.push(this._createBundleSection(leafBundle));
-          leafBundle = [];
-        }
-        sections.push(this._buildSection(child));
-      } else if (child.type === 'ROW' && child.children?.length) {
-        for (const rowChild of child.children) leafBundle.push(this._buildField(rowChild));
-      } else {
-        leafBundle.push(this._buildField(child));
-      }
-    }
-
-    if (leafBundle.length) sections.push(this._createBundleSection(leafBundle));
-    return sections;
-  }
-
-  private _buildSection(field: FieldConfig): ConfigSectionNode {
-    const children = field.sectionConfig?.children ?? field.children ?? [];
-    const fields: ConfigFieldNode[] = [];
-    const subsections: ConfigSectionNode[] = [];
-
-    for (const child of children) {
-      if (this._isSection(child)) {
-        subsections.push(this._buildSection(child));
-      } else if (child.type === 'ROW' && child.children?.length) {
-        for (const rowChild of child.children) fields.push(this._buildField(rowChild));
-      } else {
-        fields.push(this._buildField(child));
-      }
-    }
-
-    const visible = (field.isEnabled ?? field.visible ?? true) && field.disabled !== true;
-    return {
-      label: field.sectionConfig?.label || field.label || field.name || 'Section',
-      fieldConfig: field,
-      sectionConfig: field.sectionConfig ?? null,
-      visible,
-      lockVisibility: field.lockVisibility === true,
-      expanded: true,
-      fields,
-      subsections,
-    };
-  }
-
-  private _createBundleSection(fields: ConfigFieldNode[]): ConfigSectionNode {
-    return {
-      label: 'Fields',
-      fieldConfig: null,
-      sectionConfig: null,
-      visible: true,
-      lockVisibility: false,
-      expanded: true,
-      fields,
-      subsections: [],
-    };
-  }
-
-  private _buildField(field: FieldConfig): ConfigFieldNode {
-    const visible = field.isEnabled ?? field.visible ?? true;
-    return {
-      fieldConfig: field,
-      label: field.label || field.name || 'Field',
-      type: field.type,
-      visible,
-      mandatory: visible ? field.required === true : false,
-      lockVisibility: field.lockVisibility === true,
-      lockMandatory: field.lockMandatory === true,
-      parentName: field.optionConfig?.dependencies?.['parentDataCode'],
-      visibilityLockedByParent: false,
-    };
-  }
-
-  private _isSection(field: FieldConfig): boolean {
-    return field.type === 'GROUP' || field.type === 'SUBFIELDS' || !!field.sectionConfig;
-  }
-
-  // ── Private: applying ─────────────────────────────────────────────────────────
-
-  private _applySection(section: ConfigSectionNode): void {
-    if (section.fieldConfig) {
-      section.fieldConfig.isEnabled = section.visible;
-      section.fieldConfig.visible = section.visible; // backward compatibility
-      section.fieldConfig.disabled = !section.visible;
-    }
-    for (const field of section.fields) this._applyField(field);
-    for (const sub of section.subsections) this._applySection(sub);
-  }
-
-  private _applyField(field: ConfigFieldNode): void {
-    field.fieldConfig.isEnabled = field.visible;
-    field.fieldConfig.visible = field.visible; // backward compatibility
-    field.fieldConfig.required = field.visible ? field.mandatory : false;
-  }
-}

package/src/lib/modules/form-field-configuration/services/field-configuration.service.ts

@@ -1,228 +0,0 @@
-import { Injectable, computed, inject, signal } from '@angular/core';
-import { FormSchema } from '../../smart-form/models/form-schema.model';
-import { ConfigSectionNode, ConfigFieldNode } from '../models/field-configuration.models';
-import { ConfigSchemaTreeService } from './config-schema-tree.service';
-
-interface FieldConfigurationState {
-  sections: ConfigSectionNode[];
-  /** Deep clone of the input schema; node references point into this object. */
-  workingSchema: FormSchema | null;
-}
-
-/**
- * Signal-based store for the form-field-configuration component.
- * Owns the section/field tree and the visibility + mandatory toggle logic.
- * Provided at the component level (one store instance per configurator).
- */
-@Injectable()
-export class FieldConfigurationService {
-  private readonly tree = inject(ConfigSchemaTreeService);
-
-  private readonly _state = signal<FieldConfigurationState>({
-    sections: [],
-    workingSchema: null,
-  });
-
-  readonly sections = computed(() => this._state().sections);
-
-  // ── Load ────────────────────────────────────────────────────────────────────
-
-  /**
-   * Initialise from an input schema. The schema is deep-cloned so the caller's
-   * object is never mutated; the tree references the clone.
-   */
-  loadSchema(schema: FormSchema): void {
-    const workingSchema: FormSchema = JSON.parse(JSON.stringify(schema));
-    const parsed = this.tree.parseSchema(workingSchema);
-    // Apply dependency rules up-front so a schema that ships with a hidden parent
-    // (e.g. country off) starts with its dependents hidden + locked.
-    const sections = this._applyDependencyRules(parsed);
-    this._state.set({ sections, workingSchema });
-  }
-
-  // ── Mutations ─────────────────────────────────────────────────────────────────
-
-  /** Expand/collapse a section. Purely visual — does not change the schema. */
-  toggleSectionExpanded(path: number[]): void {
-    this._updateSectionAtPath(path, s => ({ ...s, expanded: !s.expanded }));
-  }
-
-  /**
-   * Toggle a section's visibility. Locked sections are ignored.
-   * Cascades: hiding disables every descendant field/subsection; showing
-   * re-enables all non-locked descendants.
-   */
-  toggleSectionVisible(path: number[]): void {
-    this._updateSectionAtPath(path, s => {
-      if (s.lockVisibility || !s.fieldConfig) return s;
-      const visible = !s.visible;
-      return this._cascadeVisibility(s, visible);
-    });
-    this._normalizeDependencies();
-  }
-
-  /**
-   * Toggle a field's visibility. Ignored for locked fields and for fields whose
-   * dependency parent is currently hidden (their toggle is disabled in the UI).
-   * Hiding a field also hides every field that depends on it (transitively).
-   */
-  toggleFieldVisible(path: number[], fieldIndex: number): void {
-    this._updateFieldAtPath(path, fieldIndex, f => {
-      if (f.lockVisibility || f.visibilityLockedByParent) return f;
-      const visible = !f.visible;
-      // "Mandatory only if visible" — drop the mandatory flag when hiding.
-      return { ...f, visible, mandatory: visible ? f.mandatory : false };
-    });
-    this._normalizeDependencies();
-  }
-
-  /** Toggle a field's mandatory flag. Ignored when locked or hidden. */
-  toggleFieldMandatory(path: number[], fieldIndex: number): void {
-    this._updateFieldAtPath(path, fieldIndex, f => {
-      if (f.lockMandatory || !f.visible) return f;
-      return { ...f, mandatory: !f.mandatory };
-    });
-  }
-
-  // ── Output ──────────────────────────────────────────────────────────────────
-
-  /**
-   * Produce the updated schema. Writes the current tree state onto the working
-   * clone and returns a fresh deep clone (safe to hand to the host / submit).
-   * Returns null if no schema has been loaded.
-   */
-  buildUpdatedSchema(): FormSchema | null {
-    const { sections, workingSchema } = this._state();
-    if (!workingSchema) return null;
-    this.tree.applyTreeToSchema(sections);
-    return JSON.parse(JSON.stringify(workingSchema));
-  }
-
-  // ── Private helpers ─────────────────────────────────────────────────────────
-
-  private _updateSectionAtPath(
-    path: number[],
-    updater: (section: ConfigSectionNode) => ConfigSectionNode,
-  ): void {
-    this._state.update(state => ({
-      ...state,
-      sections: this._mapSectionAtPath(state.sections, path, 0, updater),
-    }));
-  }
-
-  private _updateFieldAtPath(
-    path: number[],
-    fieldIndex: number,
-    updater: (field: ConfigFieldNode) => ConfigFieldNode,
-  ): void {
-    this._updateSectionAtPath(path, section => ({
-      ...section,
-      fields: section.fields.map((f, i) => (i === fieldIndex ? updater(f) : f)),
-    }));
-  }
-
-  private _mapSectionAtPath(
-    sections: ConfigSectionNode[],
-    path: number[],
-    depth: number,
-    updater: (section: ConfigSectionNode) => ConfigSectionNode,
-  ): ConfigSectionNode[] {
-    return sections.map((section, i) => {
-      if (i !== path[depth]) return section;
-      if (depth === path.length - 1) return updater(section);
-      return {
-        ...section,
-        subsections: this._mapSectionAtPath(section.subsections, path, depth + 1, updater),
-      };
-    });
-  }
-
-  /** Re-apply field dependency rules to the current tree and commit the result. */
-  private _normalizeDependencies(): void {
-    this._state.update(state => ({
-      ...state,
-      sections: this._applyDependencyRules(state.sections),
-    }));
-  }
-
-  /**
-   * Enforce field dependencies expressed via `optionConfig.dependencies.parentDataCode`.
-   * A field can only be visible when its dependency parent is visible; hiding a
-   * parent cascades (transitively) to every dependent field. Locked-visible fields
-   * are never force-hidden.
-   *
-   * Returns a new tree with each field's `visible` / `mandatory` adjusted and its
-   * derived `visibilityLockedByParent` flag set (drives the disabled toggle in the UI).
-   */
-  private _applyDependencyRules(sections: ConfigSectionNode[]): ConfigSectionNode[] {
-    // 1. Gather every named field.
-    const allFields: ConfigFieldNode[] = [];
-    const collect = (secs: ConfigSectionNode[]): void => {
-      for (const s of secs) {
-        allFields.push(...s.fields);
-        collect(s.subsections);
-      }
-    };
-    collect(sections);
-
-    // 2. Resolve effective visibility to a fixed point over the parent chain.
-    const effective = new Map<string, boolean>();
-    for (const f of allFields) {
-      const name = f.fieldConfig.name;
-      if (name) effective.set(name, f.visible);
-    }
-    let changed = true;
-    let guard = 0;
-    const maxIterations = allFields.length + 2;
-    while (changed && guard++ < maxIterations) {
-      changed = false;
-      for (const f of allFields) {
-        const name = f.fieldConfig.name;
-        if (!name || f.lockVisibility || !f.parentName) continue;
-        // Parent hidden (and known) → this field must be hidden.
-        if (effective.get(f.parentName) === false && effective.get(name) !== false) {
-          effective.set(name, false);
-          changed = true;
-        }
-      }
-    }
-
-    // 3. Rebuild the tree applying the resolved visibility + lock flag.
-    const rebuildFields = (fields: ConfigFieldNode[]): ConfigFieldNode[] =>
-      fields.map(f => {
-        const name = f.fieldConfig.name;
-        const resolved = name && effective.has(name) ? effective.get(name)! : f.visible;
-        const newVisible = f.lockVisibility ? f.visible : resolved;
-        const parentHidden = !!f.parentName && effective.get(f.parentName) === false;
-        return {
-          ...f,
-          visible: newVisible,
-          mandatory: newVisible ? f.mandatory : false,
-          visibilityLockedByParent: parentHidden && !f.lockVisibility,
-        };
-      });
-    const rebuildSections = (secs: ConfigSectionNode[]): ConfigSectionNode[] =>
-      secs.map(s => ({
-        ...s,
-        fields: rebuildFields(s.fields),
-        subsections: rebuildSections(s.subsections),
-      }));
-    return rebuildSections(sections);
-  }
-
-  /** Recursively set visibility on a section and all its descendants (respecting locks). */
-  private _cascadeVisibility(section: ConfigSectionNode, visible: boolean): ConfigSectionNode {
-    return {
-      ...section,
-      visible,
-      fields: section.fields.map(f =>
-        f.lockVisibility
-          ? f
-          : { ...f, visible, mandatory: visible ? f.mandatory : false },
-      ),
-      subsections: section.subsections.map(sub =>
-        sub.lockVisibility ? sub : this._cascadeVisibility(sub, visible),
-      ),
-    };
-  }
-}

package/src/lib/modules/material/material.module.ts

@@ -1,94 +0,0 @@
-import { NgModule } from "@angular/core";
-import { MatCardModule } from '@angular/material/card';
-import { MatSnackBarModule } from "@angular/material/snack-bar";
-import { MatCheckboxModule } from '@angular/material/checkbox'
-import { MatDividerModule } from '@angular/material/divider';
-import { MatRadioModule } from '@angular/material/radio';
-import { MatDialogModule } from "@angular/material/dialog";
-import { MatFormFieldModule } from '@angular/material/form-field';
-import { MatIconModule } from '@angular/material/icon';
-import { MatButtonModule } from "@angular/material/button";
-import { MatMenuModule } from '@angular/material/menu';
-import { MatDatepickerModule } from '@angular/material/datepicker';
-import { MatTabsModule } from '@angular/material/tabs';
-import { MatNativeDateModule } from "@angular/material/core";
-import { MatInputModule } from '@angular/material/input';
-import { MatProgressBarModule } from '@angular/material/progress-bar';
-import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
-import { MatSelectModule } from '@angular/material/select';
-import { MatTooltipModule } from '@angular/material/tooltip';
-import {MatSliderModule} from '@angular/material/slider';
-import {MatListModule} from '@angular/material/list';
-import {MatChipsModule} from '@angular/material/chips';
-import {MatPaginatorModule} from '@angular/material/paginator';
-import {MatTableModule} from '@angular/material/table';
-import {MatExpansionModule} from '@angular/material/expansion';
-import {CdkAccordionModule} from '@angular/cdk/accordion';
-import { MatSortModule } from "@angular/material/sort";
-import {MatAutocompleteModule} from '@angular/material/autocomplete';
-import {MatSlideToggleModule} from '@angular/material/slide-toggle';
-import {MatButtonToggleModule} from '@angular/material/button-toggle';
-
-@NgModule({
-  imports: [
-    MatCardModule,
-    MatSnackBarModule,
-    MatCheckboxModule,
-    MatDividerModule,
-    MatSelectModule,
-    MatRadioModule,
-    MatDialogModule,
-    MatFormFieldModule,
-    MatDatepickerModule,
-    MatNativeDateModule,
-    MatInputModule,
-    MatIconModule,
-    MatProgressSpinnerModule,
-    MatTabsModule,
-    MatButtonModule,
-    MatMenuModule,
-    MatTabsModule,
-    MatProgressBarModule,
-    MatTooltipModule,
-    MatSliderModule,
-    MatListModule,
-    MatChipsModule,
-    MatSortModule,
-    MatAutocompleteModule,
-    MatSlideToggleModule,
-    MatButtonToggleModule
-  ],
-  exports: [
-    MatCardModule,
-    MatSnackBarModule,
-    MatCheckboxModule,
-    MatDividerModule,
-    MatSelectModule,
-    MatRadioModule,
-    MatDialogModule,
-    MatFormFieldModule,
-    MatDatepickerModule,
-    MatNativeDateModule,
-    MatInputModule,
-    MatIconModule,
-    MatProgressSpinnerModule,
-    MatTabsModule,
-    MatButtonModule,
-    MatMenuModule,
-    MatTabsModule,
-    MatProgressBarModule,
-    MatTooltipModule,
-    MatSliderModule,
-    MatListModule,
-    MatChipsModule,
-    MatPaginatorModule,
-    MatTableModule,
-    MatExpansionModule,
-    CdkAccordionModule,
-    MatSortModule,
-    MatAutocompleteModule,
-    MatSlideToggleModule,
-    MatButtonToggleModule
-  ]
-})
-export class MaterialModule { }