@rxap/schematic-angular 18.1.0-dev.1 → 18.1.0-dev.3

package/src/schematics/accordion/accordion-component/schema.d.ts

@@ -1,21 +1,4 @@
-import {
-  DataProperty,
-  TypeImport,
-  UpstreamOptions,
-} from '@rxap/ts-morph';
-import { AccordionIdentifier } from '../../../lib/accordion-identifier';
-import { AccordionHeader } from '../../../lib/accordion/accordion-header';
-import { AccordionItem } from '../../../lib/accordion/accordion-item';
+import { Accordion } from '../../../lib/accordion/accordion';
 import { AngularOptions } from '../../../lib/angular-options';
-import { Persistent } from '../../../lib/persistent';
 
-export interface AccordionComponentOptions extends AngularOptions {
-  itemList?: Array<AccordionItem>;
-  multiple?: boolean;
-  persistent?: Persistent;
-  header?: AccordionHeader;
-  identifier?: AccordionIdentifier;
-  upstream?: UpstreamOptions;
-  propertyList?: DataProperty[];
-  importList?: TypeImport[];
-}
+export type AccordionComponentOptions = Accordion & AngularOptions;

package/src/schematics/accordion/accordion-component/schema.json

@@ -6,65 +6,7 @@
       "$ref": "#/definitions/angular"
     },
     {
-      "type": "object",
-      "properties": {
-        "multiple": {
-          "type": "boolean",
-          "description": "Whether the accordion should allow multiple panels to be expanded at the same time",
-          "default": false,
-          "alias": "multi"
-        },
-        "persistent": {
-          "oneOf": [
-            {
-              "type": "object",
-              "properties": {
-                "key": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "key"
-              ]
-            },
-            {
-              "type": "object",
-              "properties": {
-                "property": {
-                  "$ref": "#/definitions/property"
-                }
-              },
-              "required": [
-                "property"
-              ]
-            }
-          ]
-        },
-        "identifier": {
-          "$ref": "#/definitions/accordionIdentifier"
-        },
-        "header": {
-          "$ref": "#/definitions/accordionHeader"
-        },
-        "itemList": {
-          "alias": "item",
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/accordionItem"
-          },
-          "description": "The list of accordion expansion panels"
-        },
-        "upstream": {
-          "$ref": "#/definitions/upstream"
-        },
-        "propertyList": {
-          "alias": "property",
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/property"
-          }
-        }
-      }
+      "$ref": "#/definitions/accordion"
     }
   ],
   "definitions": {
@@ -140,6 +82,79 @@
         }
       ]
     },
+    "accordion": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "The name of the accordion component"
+        },
+        "importList": {
+          "alias": "import",
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/type"
+          },
+          "description": "The list of imports"
+        },
+        "multiple": {
+          "type": "boolean",
+          "description": "Whether the accordion should allow multiple panels to be expanded at the same time",
+          "default": false,
+          "alias": "multi"
+        },
+        "persistent": {
+          "oneOf": [
+            {
+              "type": "object",
+              "properties": {
+                "key": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "key"
+              ]
+            },
+            {
+              "type": "object",
+              "properties": {
+                "property": {
+                  "$ref": "#/definitions/property"
+                }
+              },
+              "required": [
+                "property"
+              ]
+            }
+          ]
+        },
+        "identifier": {
+          "$ref": "#/definitions/accordionIdentifier"
+        },
+        "header": {
+          "$ref": "#/definitions/accordionHeader"
+        },
+        "itemList": {
+          "alias": "item",
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/accordionItem"
+          },
+          "description": "The list of accordion expansion panels"
+        },
+        "upstream": {
+          "$ref": "#/definitions/upstream"
+        },
+        "propertyList": {
+          "alias": "property",
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/property"
+          }
+        }
+      }
+    },
     "accordionHeader": {
       "oneOf": [
         {
@@ -214,6 +229,9 @@
         },
         {
           "$ref": "#/definitions/treeTableAccordionItem"
+        },
+        {
+          "$ref": "#/definitions/nestedAccordionItem"
         }
       ]
     },
@@ -268,6 +286,58 @@
         }
       ]
     },
+    "autocompleteFormControl": {
+      "allOf": [
+        {
+          "$ref": "#/definitions/baseFormControl"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "formField": {
+              "$ref": "#/definitions/formField"
+            },
+            "kind": {
+              "type": "string",
+              "const": "autocomplete"
+            },
+            "placeholder": {
+              "type": "string"
+            },
+            "toDisplay": {
+              "type": "object",
+              "properties": {
+                "property": {
+                  "$ref": "#/definitions/property"
+                }
+              }
+            },
+            "toValue": {
+              "type": "object",
+              "properties": {
+                "property": {
+                  "$ref": "#/definitions/property"
+                }
+              }
+            },
+            "upstream": {
+              "$ref": "#/definitions/upstream"
+            },
+            "resolver": {
+              "type": "object",
+              "properties": {
+                "upstream": {
+                  "$ref": "#/definitions/upstream"
+                }
+              }
+            }
+          },
+          "required": [
+            "kind"
+          ]
+        }
+      ]
+    },
     "autocompleteTableSelectFormControl": {
       "allOf": [
         {
@@ -1159,6 +1229,9 @@
             },
             {
               "$ref": "#/definitions/autocompleteTableSelectFormControl"
+            },
+            {
+              "$ref": "#/definitions/autocompleteFormControl"
             }
           ]
         }
@@ -1611,6 +1684,29 @@
         }
       ]
     },
+    "nestedAccordionItem": {
+      "allOf": [
+        {
+          "$ref": "#/definitions/baseAccordionItem"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "kind": {
+              "type": "string",
+              "const": "nested"
+            },
+            "accordion": {
+              "$ref": "#/definitions/accordion"
+            }
+          },
+          "required": [
+            "kind",
+            "accordion"
+          ]
+        }
+      ]
+    },
     "openApiTableAction": {
       "allOf": [
         {

package/src/schematics/accordion/accordion-component/template.schema.json

@@ -6,84 +6,15 @@
       "$ref": "#/definitions/angular"
     },
     {
-      "type": "object",
-      "properties": {
-        "multiple": {
-          "type": "boolean",
-          "description": "Whether the accordion should allow multiple panels to be expanded at the same time",
-          "default": false,
-          "alias": "multi"
-        },
-        "persistent": {
-          "oneOf": [
-            {
-              "type": "object",
-              "properties": {
-                "key": {
-                  "type": "string"
-                }
-              },
-              "required": ["key"]
-            },
-            {
-              "type": "object",
-              "properties": {
-                "property": {
-                  "$ref": "#/definitions/property"
-                }
-              },
-              "required": ["property"]
-            }
-          ]
-        },
-        "identifier": {
-          "$ref": "#/definitions/accordionIdentifier"
-        },
-        "header": {
-          "$ref": "#/definitions/accordionHeader"
-        },
-        "itemList": {
-          "alias": "item",
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/accordionItem"
-          },
-          "description": "The list of accordion expansion panels"
-        },
-        "upstream": {
-          "$ref": "#/definitions/upstream"
-        },
-        "propertyList": {
-          "alias": "property",
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/property"
-          }
-        }
-      }
+      "$ref": "#/definitions/accordion"
     }
   ],
-
-
-
   "definitions": {
     "angular": {
       "$ref": "../../angular.schema.json"
     },
-    "accordionItem": {
-      "$ref": "../../accordion-item.schema.json"
-    },
-    "property": {
-      "$ref": "../../property.schema.json"
-    },
-    "accordionIdentifier": {
-      "$ref": "../../accordion-identifier.schema.json"
-    },
-    "accordionHeader": {
-      "$ref": "../../accordion-header.schema.json"
-    },
-    "upstream": {
-      "$ref": "../../upstream.schema.json"
+    "accordion": {
+      "$ref": "../../accordion.schema.json"
     }
   }
 }

package/src/schematics/accordion/accordion-item-component/files/component/__componentName__.component.html.template

@@ -1,4 +1,4 @@
-<mat-progress-bar *ngIf="panelDataSource.loading$ | async" mode="indeterminate"></mat-progress-bar>
+<mat-progress-bar class="py-2" *ngIf="loading()" mode="indeterminate"></mat-progress-bar>
 <ng-template #errorTemplate let-error let-refresh="refresh">
   <<%= prefix %>-data-source-error [error]="error" [refresh]="refresh"></<%= prefix %>-data-source-error>
 </ng-template>

package/src/schematics/accordion/accordion-item-component/files/component/__componentName__.component.stories.ts.hbs

@@ -0,0 +1,40 @@
+import { Meta, moduleMetadata, StoryObj } from '@storybook/angular';
+import { ACCORDION_DATA_SOURCE } from '@rxap/data-source/accordion';
+import { {{ classify accordionName }}DataSource } from '../{{ accordionName }}.data-source';
+import { faker } from '@faker-js/faker';
+import { {{ classify componentName }}Component } from './{{ name }}-panel.component';
+{{#if method }}
+import { {{ method.name }} } from '{{ method.moduleSpecifier }}';
+import { {{ method.response }} } from '{{ method.responseModuleSpecifier }}';
+{{/if}}
+import { ProvideActivatedRoutes, ProvideMethodMock } from 'angular-testing';
+{{#if method }}
+const data: {{ method.response }} = {
+  uuid: faker.datatype.uuid(),
+};
+{{/if}}
+
+const meta: Meta<{{ classify componentName }}Component> = {
+  component: {{ classify componentName }}Component,
+  title: '{{ classify feature }} / {{ classify accordionName }} / {{ classify componentName }}',
+  decorators: [
+    moduleMetadata({
+      providers: [
+        {
+          provide: ACCORDION_DATA_SOURCE,
+          useClass: {{ classify accordionName }}DataSource,
+        },
+        ProvideActivatedRoutes({params: {uuid: faker.datatype.uuid()}}),
+        {{#if method }}
+        ProvideMethodMock({{ method.name }}, () => structuredClone(data)),
+        {{/if}}
+      ],
+    }),
+  ],
+};
+export default meta;
+type Story = StoryObj<{{ classify componentName }}Component>;
+
+export const Primary: Story = {
+  args: {},
+};

package/src/schematics/accordion/accordion-item-component/index.d.ts

@@ -1,19 +1,15 @@
 import { Rule } from '@angular-devkit/schematics';
 import { Normalized } from '@rxap/utilities';
-import { BaseAccordionItem, NormalizedBaseAccordionItem } from '../../../lib/accordion/item/base-accordion-item';
+import { AccordionItem, NormalizedAccordionItem } from '../../../lib/accordion/accordion-item';
 import { AngularOptions, NormalizedAngularOptions } from '../../../lib/angular-options';
 import { AccordionItemComponentOptions } from './schema';
-export type AccordionItemStandaloneComponentOptions = Omit<AccordionItemComponentOptions, 'kind'>;
-export interface NormalizedAccordionItemStandaloneComponentOptions extends Readonly<Normalized<Omit<AccordionItemStandaloneComponentOptions, keyof AngularOptions | keyof BaseAccordionItem>> & NormalizedAngularOptions & NormalizedBaseAccordionItem> {
-    componentName: string;
-    controllerName: string;
-}
-export declare function NormalizeAccordionItemStandaloneComponentOptions(options: Readonly<AccordionItemStandaloneComponentOptions>): NormalizedAccordionItemStandaloneComponentOptions;
+export type NormalizedAccordionItemStandaloneComponentOptions = Readonly<Normalized<Omit<AccordionItemComponentOptions, keyof AngularOptions | keyof AccordionItem>>> & NormalizedAngularOptions & NormalizedAccordionItem & Readonly<NonNullable<Pick<AngularOptions, 'controllerName' | 'componentName' | 'directory' | 'nestModule'>>>;
+export declare function NormalizeAccordionItemStandaloneComponentOptions(options: Readonly<AccordionItemComponentOptions>): NormalizedAccordionItemStandaloneComponentOptions;
 export type NormalizedAccordionItemComponentOptions = Readonly<NormalizedAccordionItemStandaloneComponentOptions & {
     kind: string;
 }>;
 export declare function NormalizeAccordionItemComponentOptions(options: Readonly<AccordionItemComponentOptions>): NormalizedAccordionItemComponentOptions;
-export declare function printAccordionItemComponentOptions(options: NormalizedAccordionItemComponentOptions, schematicName?: string): void;
+export declare function printAccordionItemComponentOptions(options: NormalizedAngularOptions & Pick<NormalizedAccordionItem, 'kind' | 'identifier'>, schematicName?: string): void;
 interface ItemOptions {
     hasSharedModifier: boolean;
     hasCollectionModifier: boolean;

package/src/schematics/accordion/accordion-item-component/index.js

@@ -14,22 +14,32 @@ const accordion_item_kind_1 = require("../../../lib/accordion/accordion-item-kin
 const angular_options_1 = require("../../../lib/angular-options");
 const backend_types_1 = require("../../../lib/backend-types");
 function NormalizeAccordionItemStandaloneComponentOptions(options) {
-    var _a, _b, _c;
     const normalizedAngularOptions = (0, angular_options_1.NormalizeAngularOptions)(options);
-    const { feature, controllerName, shared } = normalizedAngularOptions;
-    const name = (0, schematics_utilities_1.dasherize)(options.name);
-    const componentName = (0, schematics_utilities_1.CoerceSuffix)(name, '-panel');
-    let accordionName = (_a = options.accordionName) !== null && _a !== void 0 ? _a : feature;
+    const { name } = normalizedAngularOptions;
+    let { directory, controllerName, componentName, } = normalizedAngularOptions;
+    let { accordionName, nestModule, } = options;
+    if (!name) {
+        throw new Error('The name is required!');
+    }
+    if (!accordionName) {
+        throw new Error('The accordion name is required!');
+    }
     accordionName = (0, schematics_utilities_1.CoerceSuffix)((0, schematics_utilities_1.dasherize)(accordionName), '-accordion');
-    const nestModule = (_b = options.nestModule) !== null && _b !== void 0 ? _b : accordionName;
-    const normalizedAccordionItem = (0, accordion_item_1.NormalizeAccordionItem)(Object.assign({ kind: accordion_item_kind_1.AccordionItemKinds.Default }, options));
-    const { modifiers } = normalizedAccordionItem;
-    const { hasSharedModifier } = GetItemOptions({ modifiers, shared });
-    return Object.freeze(Object.assign(Object.assign(Object.assign({}, normalizedAngularOptions), normalizedAccordionItem), { controllerName: controllerName !== null && controllerName !== void 0 ? controllerName : (0, schematics_ts_morph_1.BuildNestControllerName)({
-            controllerName: name,
-            // nestModule: hasSharedModifier ? undefined : nestModule,
-        }), name,
-        nestModule, modifiers: (_c = options.modifiers) !== null && _c !== void 0 ? _c : [], accordionName: accordionName, directory: (0, path_1.join)(accordionName, componentName), componentName }));
+    componentName !== null && componentName !== void 0 ? componentName : (componentName = (0, schematics_utilities_1.CoerceSuffix)(name, '-panel'));
+    directory !== null && directory !== void 0 ? directory : (directory = (0, path_1.join)(accordionName, componentName));
+    if (!directory.endsWith(componentName)) {
+        directory = (0, path_1.join)(directory, componentName);
+    }
+    nestModule !== null && nestModule !== void 0 ? nestModule : (nestModule = accordionName);
+    controllerName !== null && controllerName !== void 0 ? controllerName : (controllerName = (0, schematics_ts_morph_1.BuildNestControllerName)({
+        controllerName: name,
+        nestModule,
+    }));
+    return Object.freeze(Object.assign(Object.assign(Object.assign({}, normalizedAngularOptions), (0, accordion_item_1.NormalizeAccordionItem)(options)), { controllerName,
+        nestModule,
+        directory,
+        componentName,
+        accordionName }));
 }
 exports.NormalizeAccordionItemStandaloneComponentOptions = NormalizeAccordionItemStandaloneComponentOptions;
 function NormalizeAccordionItemComponentOptions(options) {
@@ -92,19 +102,19 @@ function panelItemOpenApiDataSourceRule(normalizedOptions) {
         name: (0, schematics_utilities_1.CoerceSuffix)(name, '-panel'),
         tsMorphTransform: (project, sourceFile, classDeclaration) => {
             classDeclaration.setExtends(`PanelAccordionDataSource<${(0, schematics_ts_morph_1.OperationIdToResponseClassName)(operationId)}>`);
-            (0, schematics_ts_morph_1.CoerceImports)(sourceFile, {
+            (0, ts_morph_1.CoerceImports)(sourceFile, {
                 namedImports: [(0, schematics_ts_morph_1.OperationIdToResponseClassName)(operationId)],
                 moduleSpecifier: (0, schematics_ts_morph_1.OperationIdToResponseClassImportPath)(operationId, scope),
             });
-            (0, schematics_ts_morph_1.CoerceImports)(sourceFile, {
+            (0, ts_morph_1.CoerceImports)(sourceFile, {
                 namedImports: [(0, schematics_ts_morph_1.OperationIdToClassName)(operationId)],
                 moduleSpecifier: (0, schematics_ts_morph_1.OperationIdToClassImportPath)(operationId, scope),
             });
-            (0, schematics_ts_morph_1.CoerceImports)(sourceFile, {
+            (0, ts_morph_1.CoerceImports)(sourceFile, {
                 moduleSpecifier: '@rxap/data-source/accordion',
                 namedImports: ['PanelAccordionDataSource'],
             });
-            (0, schematics_ts_morph_1.CoerceImports)(sourceFile, {
+            (0, ts_morph_1.CoerceImports)(sourceFile, {
                 moduleSpecifier: '@angular/core',
                 namedImports: ['inject'],
             });
@@ -141,7 +151,7 @@ function panelItemLocalDataSourceRule(normalizedOptions) {
             directory,
             name: componentName,
             tsMorphTransform: (project, sourceFile) => {
-                (0, schematics_ts_morph_1.CoerceImports)(sourceFile, [
+                (0, ts_morph_1.CoerceImports)(sourceFile, [
                     {
                         namedImports: ['faker'],
                         moduleSpecifier: '@faker-js/faker',
@@ -168,23 +178,23 @@ function panelItemLocalDataSourceRule(normalizedOptions) {
             name: (0, schematics_utilities_1.CoerceSuffix)(name, '-panel'),
             tsMorphTransform: (project, sourceFile, classDeclaration) => {
                 classDeclaration.setExtends(`PanelAccordionDataSource<${(0, utilities_1.classify)(componentName)}>`);
-                (0, schematics_ts_morph_1.CoerceImports)(sourceFile, {
+                (0, ts_morph_1.CoerceImports)(sourceFile, {
                     namedImports: [(0, utilities_1.classify)(componentName)],
                     moduleSpecifier: `./${(0, schematics_utilities_1.dasherize)(componentName)}`,
                 });
-                (0, schematics_ts_morph_1.CoerceImports)(sourceFile, {
+                (0, ts_morph_1.CoerceImports)(sourceFile, {
                     namedImports: [(0, utilities_1.classify)(componentName) + 'Method'],
                     moduleSpecifier: `./${(0, schematics_utilities_1.dasherize)(componentName)}.method`,
                 });
-                (0, schematics_ts_morph_1.CoerceImports)(sourceFile, {
+                (0, ts_morph_1.CoerceImports)(sourceFile, {
                     moduleSpecifier: '@angular/core',
                     namedImports: ['Inject'],
                 });
-                (0, schematics_ts_morph_1.CoerceImports)(sourceFile, {
+                (0, ts_morph_1.CoerceImports)(sourceFile, {
                     moduleSpecifier: '@angular/core',
                     namedImports: ['inject'],
                 });
-                (0, schematics_ts_morph_1.CoerceImports)(sourceFile, {
+                (0, ts_morph_1.CoerceImports)(sourceFile, {
                     moduleSpecifier: '@rxap/data-source/accordion',
                     namedImports: ['PanelAccordionDataSource'],
                 });
@@ -224,8 +234,24 @@ function panelItemBackendRule(normalizedOptions) {
     return (0, schematics_1.noop)();
 }
 function panelItemRule(normalizedOptions) {
-    const { name, directory, project, feature, shared, componentName, } = normalizedOptions;
-    const templateOptions = Object.assign(Object.assign({}, core_1.strings), normalizedOptions);
+    const { name, directory, project, feature, shared, componentName, importList, backend } = normalizedOptions;
+    let methodName = null;
+    let methodModuleSpecifier = null;
+    let methodResponse = null;
+    let methodResponseModuleSpecifier = null;
+    if (backend.kind === backend_types_1.BackendTypes.NESTJS) {
+        const operationId = buildGetOperationId(normalizedOptions);
+        methodName = (0, ts_morph_1.OperationIdToRemoteMethodClassName)(operationId);
+        methodModuleSpecifier = (0, ts_morph_1.OperationIdToClassRemoteMethodImportPath)(operationId, normalizedOptions.scope);
+        methodResponse = (0, schematics_ts_morph_1.OperationIdToResponseClassName)(operationId);
+        methodResponseModuleSpecifier = (0, schematics_ts_morph_1.OperationIdToResponseClassImportPath)(operationId, normalizedOptions.scope);
+    }
+    const templateOptions = Object.assign(Object.assign(Object.assign({}, core_1.strings), normalizedOptions), { method: backend.kind === backend_types_1.BackendTypes.NESTJS ? {
+            name: methodName,
+            moduleSpecifier: methodModuleSpecifier,
+            response: methodResponse,
+            responseModuleSpecifier: methodResponseModuleSpecifier,
+        } : null });
     return (0, schematics_1.chain)([
         (0, schematics_ts_morph_1.CoerceComponentRule)({
             name: componentName,
@@ -243,14 +269,15 @@ function panelItemRule(normalizedOptions) {
                 (0, ts_morph_1.CoerceComponentImport)(classDeclaration, { name: 'DataSourceErrorComponent', moduleSpecifier: '@rxap/data-source' });
                 (0, ts_morph_1.CoerceComponentImport)(classDeclaration, { name: 'AsyncPipe', moduleSpecifier: '@angular/common' });
                 (0, ts_morph_1.CoerceComponentImport)(classDeclaration, { name: 'JsonPipe', moduleSpecifier: '@angular/common' });
+                (0, ts_morph_1.CoerceComponentImport)(classDeclaration, { name: 'NgIf', moduleSpecifier: '@angular/common' });
                 const pipeDataSourceName = `${(0, utilities_1.classify)(name)}PanelDataSource`;
                 (0, schematics_ts_morph_1.AddComponentProvider)(sourceFile, pipeDataSourceName);
-                (0, schematics_ts_morph_1.CoerceImports)(sourceFile, {
+                (0, ts_morph_1.CoerceImports)(sourceFile, {
                     moduleSpecifier: `./${(0, schematics_utilities_1.dasherize)(name)}-panel.data-source`,
                     namedImports: [pipeDataSourceName],
                 });
-                (0, schematics_ts_morph_1.CoerceImports)(sourceFile, {
-                    namedImports: ['inject'],
+                (0, ts_morph_1.CoerceImports)(sourceFile, {
+                    namedImports: ['inject', 'signal', 'computed', 'toSignal'],
                     moduleSpecifier: '@angular/core'
                 });
                 (0, ts_morph_1.CoercePropertyDeclaration)(classDeclaration, 'panelDataSource', {
@@ -258,6 +285,24 @@ function panelItemRule(normalizedOptions) {
                     initializer: `inject(${pipeDataSourceName})`,
                     scope: ts_morph_2.Scope.Public,
                 });
+                (0, ts_morph_1.CoercePropertyDeclaration)(classDeclaration, 'updating', {
+                    isReadonly: true,
+                    initializer: `signal(false)`,
+                    scope: ts_morph_2.Scope.Public,
+                });
+                (0, ts_morph_1.CoercePropertyDeclaration)(classDeclaration, 'loading', {
+                    isReadonly: true,
+                    initializer: `computed(() => this.updating() || this.panelDataSource.loading())`,
+                    scope: ts_morph_2.Scope.Public,
+                });
+                (0, ts_morph_1.CoercePropertyDeclaration)(classDeclaration, 'data', {
+                    isReadonly: true,
+                    initializer: `toSignal(this.panelDataSource.connect({id: 'to-signal-${name}-panel'}))`,
+                    scope: ts_morph_2.Scope.Public,
+                });
+                for (const angularImport of importList) {
+                    (0, ts_morph_1.CoerceComponentImport)(classDeclaration, angularImport);
+                }
             }
         }),
         panelItemBackendRule(normalizedOptions),
@@ -294,6 +339,9 @@ function itemRule(normalizedOptions) {
         case accordion_item_kind_1.AccordionItemKinds.Switch:
             rules.push((0, schematics_utilities_1.ExecuteSchematic)('accordion-item-switch-component', normalizedOptions));
             break;
+        case accordion_item_kind_1.AccordionItemKinds.Nested:
+            rules.push((0, schematics_utilities_1.ExecuteSchematic)('accordion-item-nested-component', normalizedOptions));
+            break;
         default:
             throw new schematics_1.SchematicsException(`Invalid accordion item type '${kind}'!`);
     }