igniteui-cli 13.2.2-beta.1 → 13.2.2

package/templates/webcomponents/TypeScriptFileUpdate.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptFileUpdate = void 0;
+const cli_core_1 = require("@igniteui/cli-core");
+const ts = require("typescript");
+const DEFAULT_ROUTES_VARIABLE = "routes";
+/**
+ * Apply various updates to typescript files using AST
+ */
+class TypeScriptFileUpdate {
+    /** Create updates for a file. Use `add<X>` methods to add transformations and `finalize` to apply and save them. */
+    constructor(targetPath) {
+        this.targetPath = targetPath;
+        this.formatOptions = { spaces: false, indentSize: 4, singleQuotes: false };
+        //#region ts.TransformerFactory
+        /** Transformation to apply edits to existing named import declarations */
+        this.importsTransformer = (context) => (rootNode) => {
+            const editImports = this.requestedImports.filter(x => x.edit);
+            // https://github.com/Microsoft/TypeScript/issues/14419#issuecomment-307256171
+            const visitor = (node) => {
+                if (node.kind === ts.SyntaxKind.ImportDeclaration &&
+                    editImports.find(x => x.from === node.moduleSpecifier.text)) {
+                    // visit just the source file main array (second visit)
+                    return visitImport(node);
+                }
+                else {
+                    node = ts.visitEachChild(node, visitor, context);
+                }
+                return node;
+            };
+            function visitImport(node) {
+                node = ts.visitEachChild(node, visitImport, context);
+                return node;
+            }
+            return ts.visitNode(rootNode, visitor);
+        };
+        this.fileSystem = cli_core_1.App.container.get(cli_core_1.FS_TOKEN);
+        this.initState();
+    }
+    /** Applies accumulated transforms, saves and formats the file */
+    finalize() {
+        // add new import statements after visitor walks:
+        this.addNewFileImports();
+        cli_core_1.TypeScriptUtils.saveFile(this.targetPath, this.targetSource);
+        this.formatFile(this.targetPath);
+        // reset state in case of further updates
+        this.initState();
+    }
+    addRoute(path, component, name, routerChildren, importAlias, routesVariable = DEFAULT_ROUTES_VARIABLE) {
+        this.addRouteModuleEntry(path, component, name, routerChildren, importAlias, routesVariable);
+    }
+    //#region File state
+    /** Initializes existing imports info, [re]sets import and `NgModule` edits */
+    initState() {
+        this.targetSource = cli_core_1.TypeScriptUtils.getFileSource(this.targetPath);
+        this.importsMeta = this.loadImportsMeta();
+        this.requestedImports = [];
+        this.createdStringLiterals = [];
+    }
+    /* load some metadata about imports */
+    loadImportsMeta() {
+        const meta = { lastIndex: 0, modulePaths: [] };
+        for (let i = 0; i < this.targetSource.statements.length; i++) {
+            const statement = this.targetSource.statements[i];
+            switch (statement.kind) {
+                case ts.SyntaxKind.ImportDeclaration:
+                    const importStmt = statement;
+                    if (importStmt.importClause && importStmt.importClause.namedBindings &&
+                        importStmt.importClause.namedBindings.kind !== ts.SyntaxKind.NamespaceImport) {
+                        // don't add imports without named (e.g. `import $ from "JQuery"` or `import "./my-module.js";`)
+                        // don't add namespace imports (`import * as fs`) as available for editing, maybe in the future
+                        meta.modulePaths.push(importStmt.moduleSpecifier.text);
+                    }
+                // don't add equals imports (`import url = require("url")`) as available for editing, maybe in the future
+                case ts.SyntaxKind.ImportEqualsDeclaration:
+                    meta.lastIndex = i + 1;
+                    break;
+                default:
+                    break;
+            }
+        }
+        return meta;
+    }
+    //#endregion File state
+    addRouteModuleEntry(path, component, name, routerChildren, importAlias, routesVariable = DEFAULT_ROUTES_VARIABLE) {
+        const isRouting = path.indexOf("routing") >= 0;
+        if (isRouting && this.targetSource.text.indexOf(path.slice(0, -3)) > 0) {
+            return;
+        }
+        const moduleName = path.substring(0, path.indexOf("-routing"));
+        if (path) {
+            const relativePath = isRouting ?
+                "./" + moduleName + "/" + path.slice(0, -3) : "./" + path + "/" + path;
+            this.requestImport(relativePath, importAlias);
+        }
+        // https://github.com/Microsoft/TypeScript/issues/14419#issuecomment-307256171
+        const transformer = (context) => (rootNode) => {
+            // the visitor that should be used when adding routes to the main route array
+            const conditionalVisitor = (node) => {
+                if (node.kind === ts.SyntaxKind.ArrayLiteralExpression) {
+                    const newObject = this.createRouteEntry(path, component, name, routerChildren);
+                    const array = node;
+                    this.createdStringLiterals.push(path, name);
+                    const notFoundWildCard = ".*";
+                    const nodes = ts.visitNodes(array.elements, visitor);
+                    const errorRouteNode = nodes.filter(element => element.getText().includes(notFoundWildCard))[0];
+                    let resultNodes = null;
+                    if (errorRouteNode) {
+                        resultNodes = nodes
+                            .slice(0, nodes.indexOf(errorRouteNode))
+                            .concat(newObject)
+                            .concat(errorRouteNode);
+                    }
+                    else {
+                        resultNodes = nodes
+                            .concat(newObject);
+                    }
+                    const elements = ts.factory.createNodeArray([
+                        ...resultNodes
+                    ]);
+                    return ts.factory.updateArrayLiteralExpression(array, elements);
+                }
+                else {
+                    return ts.visitEachChild(node, conditionalVisitor, context);
+                }
+            };
+            let visitCondition;
+            if (!isRouting) {
+                visitCondition = (node) => {
+                    return node.kind === ts.SyntaxKind.VariableDeclaration &&
+                        node.name.getText() === routesVariable &&
+                        node.type.getText() === "Route[]";
+                };
+            }
+            else {
+                visitCondition = (node) => {
+                    return undefined;
+                };
+            }
+            const visitor = this.createVisitor(conditionalVisitor, visitCondition, context);
+            context.enableSubstitution(ts.SyntaxKind.ClassDeclaration);
+            return ts.visitNode(rootNode, visitor);
+        };
+        this.targetSource = ts.transform(this.targetSource, [transformer], {
+            pretty: true // oh well..
+        }).transformed[0];
+        this.finalize();
+    }
+    requestImport(modulePath, routerAlias) {
+        const existing = this.requestedImports.find(x => x.from === modulePath);
+        if (!existing) {
+            // new imports, check if already exists in file
+            this.requestedImports.push({
+                as: routerAlias,
+                from: modulePath,
+                edit: this.importsMeta.modulePaths.indexOf(modulePath) !== -1
+            });
+        }
+        else {
+            return;
+        }
+    }
+    /** Add `import` statements not previously found in the file  */
+    addNewFileImports() {
+        const newImports = this.requestedImports.filter(x => !x.edit);
+        if (!newImports.length) {
+            return;
+        }
+        const newStatements = ts.factory.createNodeArray([
+            ...this.targetSource.statements.slice(0, this.importsMeta.lastIndex),
+            ...newImports.map(x => this.createIdentifierImport(x.from, x.as)),
+            ...this.targetSource.statements.slice(this.importsMeta.lastIndex)
+        ]);
+        newImports.forEach(x => this.createdStringLiterals.push(x.from));
+        this.targetSource = ts.factory.updateSourceFile(this.targetSource, newStatements);
+    }
+    createIdentifierImport(importPath, as) {
+        let exportedObject;
+        let exportedObjectName;
+        let importClause;
+        if (as) {
+            exportedObject = "routes";
+            exportedObjectName = as.replace(/\s/g, "");
+            importClause = ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+                ts.factory.createImportSpecifier(false, ts.factory.createIdentifier(exportedObject), ts.factory.createIdentifier(exportedObjectName))
+            ]));
+        }
+        else {
+            importClause = undefined;
+        }
+        const importDeclaration = ts.factory.createImportDeclaration(undefined, importClause, ts.factory.createStringLiteral(importPath, true), undefined);
+        return importDeclaration;
+    }
+    //#endregion ts.TransformerFactory
+    //#region Formatting
+    /** Format a TS source file, very TBD */
+    formatFile(filePath) {
+        // formatting via LanguageService https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API
+        // https://github.com/Microsoft/TypeScript/issues/1651
+        let text = this.fileSystem.readFile(filePath);
+        // create the language service files
+        const services = ts.createLanguageService(this.getLanguageHost(filePath), ts.createDocumentRegistry());
+        this.readFormatConfigs();
+        const textChanges = services.getFormattingEditsForDocument(filePath, this.getFormattingOptions());
+        text = this.applyChanges(text, textChanges);
+        if (this.formatOptions.singleQuotes) {
+            for (const str of this.createdStringLiterals) {
+                // there shouldn't be duplicate strings of these
+                text = text.replace(`"${str}"`, `'${str}'`);
+            }
+        }
+        this.fileSystem.writeFile(filePath, text);
+    }
+    /**  Try and parse formatting from project `.editorconfig` / `tslint.json` */
+    readFormatConfigs() {
+        if (this.fileSystem.fileExists(".editorconfig")) {
+            // very basic parsing support
+            const text = this.fileSystem.readFile(".editorconfig", "utf-8");
+            const options = text
+                .replace(/\s*[#;].*([\r\n])/g, "$1") //remove comments
+                .replace(/\[(?!\*\]|\*.ts).+\][^\[]+/g, "") // leave [*]/[*.ts] sections
+                .split(/\r\n|\r|\n/)
+                .reduce((obj, x) => {
+                if (x.indexOf("=") !== -1) {
+                    const pair = x.split("=");
+                    obj[pair[0].trim()] = pair[1].trim();
+                }
+                return obj;
+            }, {});
+            this.formatOptions.spaces = options["indent_style"] === "space";
+            if (options["indent_size"]) {
+                this.formatOptions.indentSize = parseInt(options["indent_size"], 10) || this.formatOptions.indentSize;
+            }
+            if (options["quote_type"]) {
+                this.formatOptions.singleQuotes = options["quote_type"] === "single";
+            }
+        }
+        if (this.fileSystem.fileExists("tslint.json")) {
+            // tslint prio - overrides other settings
+            const options = JSON.parse(this.fileSystem.readFile("tslint.json", "utf-8"));
+            if (options.rules && options.rules.indent && options.rules.indent[0]) {
+                this.formatOptions.spaces = options.rules.indent[1] === "spaces";
+                if (options.rules.indent[2]) {
+                    this.formatOptions.indentSize = parseInt(options.rules.indent[2], 10);
+                }
+            }
+            if (options.rules && options.rules.quotemark && options.rules.quotemark[0]) {
+                this.formatOptions.singleQuotes = options.rules.quotemark.indexOf("single") !== -1;
+            }
+        }
+    }
+    /**
+     * Apply formatting changes (position based) in reverse
+     * from https://github.com/Microsoft/TypeScript/issues/1651#issuecomment-69877863
+     */
+    applyChanges(orig, changes) {
+        let result = orig;
+        for (let i = changes.length - 1; i >= 0; i--) {
+            const change = changes[i];
+            const head = result.slice(0, change.span.start);
+            const tail = result.slice(change.span.start + change.span.length);
+            result = head + change.newText + tail;
+        }
+        return result;
+    }
+    /** Return source file formatting options */
+    getFormattingOptions() {
+        const formatOptions = {
+            // tslint:disable:object-literal-sort-keys
+            indentSize: this.formatOptions.indentSize,
+            tabSize: 4,
+            newLineCharacter: ts.sys.newLine,
+            convertTabsToSpaces: this.formatOptions.spaces,
+            indentStyle: ts.IndentStyle.Smart,
+            insertSpaceAfterCommaDelimiter: true,
+            insertSpaceAfterSemicolonInForStatements: true,
+            insertSpaceBeforeAndAfterBinaryOperators: true,
+            insertSpaceAfterKeywordsInControlFlowStatements: true,
+            insertSpaceAfterTypeAssertion: true
+            // tslint:enable:object-literal-sort-keys
+        };
+        return formatOptions;
+    }
+    /** Get language service host, sloppily */
+    getLanguageHost(filePath) {
+        const files = {};
+        files[filePath] = { version: 0 };
+        // create the language service host to allow the LS to communicate with the host
+        const servicesHost = {
+            getCompilationSettings: () => ({}),
+            getScriptFileNames: () => Object.keys(files),
+            getScriptVersion: fileName => files[fileName] && files[fileName].version.toString(),
+            getScriptSnapshot: fileName => {
+                if (!this.fileSystem.fileExists(fileName)) {
+                    return undefined;
+                }
+                return ts.ScriptSnapshot.fromString(this.fileSystem.readFile(fileName));
+            },
+            getCurrentDirectory: () => process.cwd(),
+            getDefaultLibFileName: options => ts.getDefaultLibFilePath(options),
+            readDirectory: ts.sys.readDirectory,
+            readFile: ts.sys.readFile,
+            fileExists: ts.sys.fileExists
+        };
+        return servicesHost;
+    }
+    //#endregion Formatting
+    /** Convert a string or string array union to array. Splits strings as comma delimited */
+    asArray(value, variables) {
+        let result = [];
+        if (value) {
+            result = typeof value === "string" ? value.split(/\s*,\s*/) : value;
+            result = result.map(x => cli_core_1.Util.applyConfigTransformation(x, variables));
+        }
+        return result;
+    }
+    createVisitor(conditionalVisitor, visitCondition, nodeContext) {
+        return function visitor(node) {
+            if (visitCondition(node)) {
+                node = ts.visitEachChild(node, conditionalVisitor, nodeContext);
+            }
+            else {
+                node = ts.visitEachChild(node, visitor, nodeContext);
+            }
+            return node;
+        };
+    }
+    createRouteEntry(filePath, className, linkText, routerAlias) {
+        const routePath = ts.factory.createPropertyAssignment("path", ts.factory.createStringLiteral(filePath, true));
+        const routeComponent = ts.factory.createPropertyAssignment("component", ts.factory.createStringLiteral(className, true));
+        const routeData = ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(linkText, true));
+        if (routerAlias) {
+            const childrenData = ts.factory.createPropertyAssignment("children", ts.factory.createIdentifier(routerAlias));
+            return ts.factory.createObjectLiteralExpression([routePath, routeComponent, routeData, childrenData]);
+        }
+        else {
+            return ts.factory.createObjectLiteralExpression([routePath, routeComponent, routeData]);
+        }
+    }
+}
+exports.TypeScriptFileUpdate = TypeScriptFileUpdate;

package/templates/webcomponents/igc-ts/accordion/default/index.js

@@ -12,5 +12,8 @@ class IgcAccordionTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIFo
         this.name = "Accordion";
         this.description = "basic IgcAccordion";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcAccordionTemplate();

package/templates/webcomponents/igc-ts/avatar/default/index.js

@@ -12,5 +12,8 @@ class IgcAvatarTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIForWe
         this.name = "Avatar";
         this.description = "basic IgcAvatar";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcAvatarTemplate();

package/templates/webcomponents/igc-ts/badge/default/index.js

@@ -12,5 +12,8 @@ class IgcBadgeTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIForWeb
         this.name = "Badge";
         this.description = "basic IgcBadge";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcBadgeTemplate();

package/templates/webcomponents/igc-ts/button/default/index.js

@@ -12,5 +12,8 @@ class IgcBButtonTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIForW
         this.name = "Button";
         this.description = "basic IgcButton";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcBButtonTemplate();

package/templates/webcomponents/igc-ts/button-group/default/index.js

@@ -12,5 +12,8 @@ class IgcTabsTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIForWebC
         this.name = "Button group";
         this.description = "basic IgcButtonGroup";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcTabsTemplate();

package/templates/webcomponents/igc-ts/calendar/default/index.js

@@ -12,5 +12,8 @@ class IgcCalendarTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIFor
         this.name = "Calendar";
         this.description = "basic IgcCalendar";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcCalendarTemplate();

package/templates/webcomponents/igc-ts/card/default/index.js

@@ -12,5 +12,8 @@ class IgcCardTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIForWebC
         this.name = "Card";
         this.description = "basic IgcCard";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcCardTemplate();

package/templates/webcomponents/igc-ts/checkbox/default/index.js

@@ -12,5 +12,8 @@ class IgcCheckboxTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIFor
         this.name = "Checkbox";
         this.description = "basic IgcCheckbox";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcCheckboxTemplate();

package/templates/webcomponents/igc-ts/chip/default/index.js

@@ -12,5 +12,8 @@ class IgcChipTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIForWebC
         this.name = "Chip";
         this.description = "Basic IgcChip";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcChipTemplate();

package/templates/webcomponents/igc-ts/circular-progress/default/index.js

@@ -12,5 +12,8 @@ class IgcCircularProgressTemplate extends IgniteUIForWebComponentsTemplate_1.Ign
         this.name = "Circular Progress";
         this.description = "Basic Circular Progress";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcCircularProgressTemplate();

package/templates/webcomponents/igc-ts/custom-templates/subscription-form/index.js

@@ -11,5 +11,8 @@ class IgcSubscriptionFormTemplate extends IgniteUIForWebComponentsTemplate_1.Ign
         this.name = "Subscription Form";
         this.description = "Subscription form with inputs, buttons and a checkbox inside";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcSubscriptionFormTemplate();

package/templates/webcomponents/igc-ts/date-time-input/default/index.js

@@ -12,5 +12,8 @@ class IgcDateTimeInputTemplate extends IgniteUIForWebComponentsTemplate_1.Ignite
         this.name = "Date Time Input";
         this.description = "basic IgcDateTimeInput";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcDateTimeInputTemplate();

package/templates/webcomponents/igc-ts/dock-manager/default/index.js

@@ -13,5 +13,8 @@ class IgcDockManagerTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUI
         this.description = "Dock Manager with most functionalities and docking options";
         this.packages = ["igniteui-dockmanager@~1.12.4"];
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcDockManagerTemplate();

package/templates/webcomponents/igc-ts/dropdown/default/index.js

@@ -12,5 +12,8 @@ class IgcDropdownTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIFor
         this.name = "Dropdown";
         this.description = "IgcDropdown with groups and disabled items";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcDropdownTemplate();

package/templates/webcomponents/igc-ts/expansion-panel/default/index.js

@@ -12,5 +12,8 @@ class IgcDropdownTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIFor
         this.name = "Expansion Panel";
         this.description = "A lightweight accordion component";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcDropdownTemplate();

package/templates/webcomponents/igc-ts/financial-chart/default/index.js

@@ -16,5 +16,8 @@ class IgcFinancialChartTemplate extends IgniteUIForWebComponentsTemplate_1.Ignit
             "igniteui-webcomponents-charts@~4.2.5"
         ];
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcFinancialChartTemplate();

package/templates/webcomponents/igc-ts/form/default/index.js

@@ -12,5 +12,8 @@ class IgcFormTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIForWebC
         this.name = "Form";
         this.description = "basic IgcForm";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcFormTemplate();

package/templates/webcomponents/igc-ts/grid/default/index.js

@@ -18,5 +18,8 @@ class IgcGridTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIForWebC
             "igniteui-webcomponents-layouts@~4.2.5"
         ];
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcGridTemplate();

package/templates/webcomponents/igc-ts/grid/grid-editing/index.js

@@ -12,5 +12,8 @@ class IgcGridEditingTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUI
         this.name = "Grid Editing";
         this.description = "IgcGrid with editing enabled";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcGridEditingTemplate();

package/templates/webcomponents/igc-ts/grid/grid-summaries/index.js

@@ -12,5 +12,8 @@ class IgcGridSummariesTemplate extends IgniteUIForWebComponentsTemplate_1.Ignite
         this.name = "Grid Summaries";
         this.description = "IgcGrid with column summaries";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcGridSummariesTemplate();

package/templates/webcomponents/igc-ts/icon/default/index.js

@@ -12,5 +12,8 @@ class IgcIconTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIForWebC
         this.name = "Icon";
         this.description = "basic IgcIcon";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcIconTemplate();

package/templates/webcomponents/igc-ts/icon-button/default/index.js

@@ -12,5 +12,8 @@ class IgcIconButtonTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIF
         this.name = "Icon Button";
         this.description = "basic IgcIconButton";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcIconButtonTemplate();

package/templates/webcomponents/igc-ts/input/default/index.js

@@ -12,5 +12,8 @@ class IgcInputTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIForWeb
         this.name = "Input";
         this.description = "basic IgcInput";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcInputTemplate();

package/templates/webcomponents/igc-ts/linear-gauge/default/index.js

@@ -16,5 +16,8 @@ class IgcLinearGaugeTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUI
             "igniteui-webcomponents-gauges@~4.2.5"
         ];
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcLinearGaugeTemplate();

package/templates/webcomponents/igc-ts/linear-progress/default/index.js

@@ -16,5 +16,8 @@ class IgcLinearProgressComponent extends IgniteUIForWebComponentsTemplate_1.Igni
             "igniteui-webcomponents-charts@~4.2.5"
         ];
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcLinearProgressComponent();

package/templates/webcomponents/igc-ts/list/default/index.js

@@ -12,5 +12,8 @@ class IgcListTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIForWebC
         this.name = "List";
         this.description = "basic IgcList";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcListTemplate();

package/templates/webcomponents/igc-ts/navbar/default/index.js

@@ -12,5 +12,8 @@ class IgcNavbarTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIForWe
         this.name = "Navbar";
         this.description = "basic IgcNavbar";
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcNavbarTemplate();

package/templates/webcomponents/igc-ts/pie-chart/default/index.js

@@ -16,5 +16,8 @@ class IgcPieChartTemplate extends IgniteUIForWebComponentsTemplate_1.IgniteUIFor
             "igniteui-webcomponents-charts@~4.2.5"
         ];
     }
+    addClassDeclaration(mainModule, projPath, name, modulePath) {
+        // not applicable with custom module
+    }
 }
 module.exports = new IgcPieChartTemplate();