@taiga-ui/cdk 2.48.0 → 2.49.2

package/schematics/ng-update/constants/tui-interactive-selectors.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TUI_INTERACTIVE_SELECTORS = [
+    'tui-primitive-textfield',
+    'tui-primitive-spin-button',
+    'tui-action',
+    'tui-input-range',
+    'tui-pagination',
+    'tui-accordion-item',
+    'tui-button',
+    'tuiButton',
+    'tuiIconButton',
+    'tui-toggle',
+    'tuiSlider',
+    'tui-slider',
+    'tui-rating',
+    'tui-input-card',
+    'tui-input-cvc',
+    'tui-input-expire',
+    'tui-editor',
+    'tui-input-color',
+    'tui-input-copy',
+    'tui-input-count',
+    'tui-input-date-time',
+    'tui-input-inline',
+    'tui-input-password',
+    'tui-input-phone-international',
+    'tui-input-phone',
+    'tui-input-range',
+    'tui-input-slider',
+    'tui-input',
+    'tui-range',
+    'tui-text-area',
+    'tui-radio-block',
+    'tui-radio-labeled',
+    'tui-radio-list',
+    'tui-radio',
+    'tui-select',
+    'tui-input-card-grouped',
+    'tui-checkbox-block',
+    'tui-checkbox-labeled',
+    'tui-combo-box',
+    'tui-input-date-range',
+    'tui-input-file',
+    'tui-input-files',
+    'tui-input-month-range',
+    'tui-input-month',
+    'tui-input-number',
+    'tui-input-time',
+    'tui-input-time',
+    'tui-multiselect',
+    'tui-filter',
+    'tui-input-tag',
+];

package/schematics/ng-update/constants/types.js

@@ -71,4 +71,9 @@ exports.TYPES_TO_RENAME = [
     {
         from: 'Country',
     },
+    {
+        from: 'NumberFormatSettings',
+        to: 'TuiNumberFormatSettings',
+        moduleSpecifier: ['@taiga-ui/core'],
+    },
 ];

package/schematics/ng-update/constants/warnings.js

@@ -27,4 +27,54 @@ exports.MIGRATION_WARNINGS = [
         moduleSpecifier: '@taiga-ui/kit',
         message: 'Use DI-token TUI_COUNTRIES_MASKS to get phone mask by country iso code',
     },
+    {
+        name: 'TuiTableModeModule',
+        moduleSpecifier: '@taiga-ui/core',
+        message: 'TuiTableModeModule has been deleted in 3.0, please use @taiga-ui/addon-table',
+    },
+    {
+        name: 'TuiColorModule',
+        moduleSpecifier: '@taiga-ui/core',
+        message: 'TuiColorModule has been deleted in 3.0, please use CSS custom properties',
+    },
+    {
+        name: 'TuiPluralizePipeModule',
+        moduleSpecifier: '@taiga-ui/core',
+        message: 'TuiPluralizePipeModule has been deleted in 3.0, please use use Angular built-in pipe https://angular.io/api/common/I18nPluralPipe ',
+    },
+    {
+        name: 'TUI_DEFAULT_COLOR_HANDLER',
+        moduleSpecifier: '@taiga-ui/addon-charts',
+        message: 'TUI_DEFAULT_COLOR_HANDLER has been deleted in 3.0, please use CSS variables',
+    },
+    {
+        name: 'TuiColorHandler',
+        moduleSpecifier: '@taiga-ui/addon-charts',
+        message: 'TuiColorHandler has been deleted in 3.0, please use CSS custom properties',
+    },
+    {
+        name: 'DEFAULT_COLORS',
+        moduleSpecifier: '@taiga-ui/addon-charts',
+        message: 'DEFAULT_COLORS has been deleted in 3.0, please use CSS variables',
+    },
+    {
+        name: 'AbstractTuiInteractive',
+        moduleSpecifier: '@taiga-ui/core',
+        message: 'pressedChange and hoveredChange outputs have been removed from AbstractTuiInteractive, please use tuiPressedChange and tuiHoveredChange directives instead',
+    },
+    {
+        name: 'AbstractTuiControl',
+        moduleSpecifier: '@taiga-ui/core',
+        message: 'pressedChange and hoveredChange outputs have been removed from AbstractTuiInteractive, please use tuiPressedChange and tuiHoveredChange directives instead',
+    },
+    {
+        name: 'AbstractTuiMultipleControl',
+        moduleSpecifier: '@taiga-ui/core',
+        message: 'pressedChange and hoveredChange outputs have been removed from AbstractTuiInteractive, please use tuiPressedChange and tuiHoveredChange directives instead',
+    },
+    {
+        name: 'AbstractTuiNullableControl',
+        moduleSpecifier: '@taiga-ui/core',
+        message: 'pressedChange and hoveredChange outputs have been removed from AbstractTuiInteractive, please use tuiPressedChange and tuiHoveredChange directives instead',
+    },
 ];

package/schematics/ng-update/index.js

@@ -9,6 +9,9 @@ const replace_const_1 = require("./steps/replace-const");
 const replace_deep_import_1 = require("./steps/replace-deep-import");
 const show_warnings_1 = require("./steps/show-warnings");
 const replace_services_1 = require("./steps/replace-services");
+const migrate_templates_1 = require("./steps/migrate-templates");
+const migrate_sliders_1 = require("./steps/migrate-sliders");
+const remove_module_1 = require("./steps/remove-module");
 function updateToV3(_) {
     return (tree, context) => tslib_1.__awaiter(this, void 0, void 0, function* () {
         context.logger.info(`taiga packages will be updated to ${versions_1.TAIGA_VERSION}`);
@@ -19,6 +22,9 @@ function updateToV3(_) {
         replace_const_1.replaceConsts();
         replace_services_1.replaceServices();
         show_warnings_1.showWarnings(context);
+        migrate_templates_1.migrateTemplates(tree);
+        migrate_sliders_1.migrateSliders(tree);
+        remove_module_1.removeModules();
         ng_morph_1.saveActiveProject();
     });
 }

package/schematics/ng-update/interfaces/template-resourse.d.ts

@@ -0,0 +1,8 @@
+export declare type TemplateResource = {
+    readonly template: string;
+    readonly componentPath: string;
+    readonly offset: number;
+} | {
+    readonly templatePath: string;
+    componentPath: string;
+};

package/schematics/ng-update/interfaces/template-resourse.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/schematics/ng-update/steps/migrate-sliders/index.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@angular-devkit/schematics';
+export declare function migrateSliders(tree: Tree): void;

package/schematics/ng-update/steps/migrate-sliders/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const migrate_input_slider_1 = require("./migrate-input-slider");
+function migrateSliders(tree) {
+    migrate_input_slider_1.migrateInputSlider(tree);
+}
+exports.migrateSliders = migrateSliders;

package/schematics/ng-update/steps/migrate-sliders/migrate-input-slider.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@angular-devkit/schematics';
+export declare function migrateInputSlider(tree: Tree): void;

package/schematics/ng-update/steps/migrate-sliders/migrate-input-slider.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ng_morph_1 = require("ng-morph");
+const devkit_file_system_1 = require("ng-morph/project/classes/devkit-file-system");
+const ng_component_input_manipulations_1 = require("../../../utils/templates/ng-component-input-manipulations");
+const ng_component_1 = require("../../../utils/angular/ng-component");
+const add_unique_import_1 = require("../../../utils/add-unique-import");
+const get_component_templates_1 = require("../../../utils/templates/get-component-templates");
+const elements_1 = require("../../../utils/templates/elements");
+function migrateInputSlider(tree) {
+    const fileSystem = new devkit_file_system_1.DevkitFileSystem(tree);
+    const templateResources = get_component_templates_1.getComponentTemplates('**/**');
+    for (const templateResource of templateResources) {
+        replaceMinMaxLabels(templateResource, fileSystem);
+    }
+}
+exports.migrateInputSlider = migrateInputSlider;
+function replaceMinMaxLabels(templateResource, fileSystem) {
+    const wasMaxLabelModified = ng_component_input_manipulations_1.replaceInputProperty({
+        templateResource,
+        fileSystem,
+        componentSelector: 'tui-input-slider',
+        from: 'maxLabel',
+        to: '[valueContent]',
+        newValue: 'tuiMigrationMinMaxLabel',
+    });
+    const wasMinLabelModified = ng_component_input_manipulations_1.replaceInputProperty({
+        templateResource,
+        fileSystem,
+        componentSelector: 'tui-input-slider',
+        from: 'minLabel',
+        to: '[valueContent]',
+        newValue: 'tuiMigrationMinMaxLabel',
+        filterFn: element => !elements_1.hasElementAttribute(element, 'maxLabel'),
+    });
+    ng_component_input_manipulations_1.removeInputProperty({
+        templateResource,
+        fileSystem,
+        componentSelector: 'tui-input-slider',
+        inputProperty: 'minLabel',
+        filterFn: element => elements_1.hasElementAttribute(element, 'maxLabel'),
+    });
+    /**
+     * We should update virtual file tree
+     * otherwise all following ng-morph commands will overwrite all previous template manipulations
+     * */
+    fileSystem.commitEdits();
+    ng_morph_1.saveActiveProject();
+    ng_morph_1.setActiveProject(ng_morph_1.createProject(fileSystem.tree, '/', '**/**'));
+    const [ngComponent] = ng_component_1.getNgComponents(templateResource.componentPath);
+    if ((wasMaxLabelModified || wasMinLabelModified) && ngComponent) {
+        add_unique_import_1.addUniqueImport(templateResource.componentPath, 'TuiContextWithImplicit', '@taiga-ui/cdk');
+        ng_morph_1.addMethods(ngComponent, {
+            name: 'tuiMigrationMinMaxLabel',
+            returnType: 'string',
+            parameters: [{ name: 'context', type: 'TuiContextWithImplicit<number>' }],
+            statements: [
+                'const currentValue = context.$implicit;',
+                'const maxValue = 100; // TODO replace with the MAX value of the input',
+                'const maxLabelText = "Max"; // TODO replace with the required label',
+                'const minValue = 0; // TODO replace with the MIN value of the input',
+                'const minLabelText = "Min"; // TODO replace with the required label',
+                'if (currentValue === maxValue) return maxLabelText;',
+                'if (currentValue === minValue) return minLabelText;',
+                'return String(currentValue);',
+            ],
+        });
+    }
+}

package/schematics/ng-update/steps/migrate-templates.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@angular-devkit/schematics';
+export declare function migrateTemplates(tree: Tree): void;

package/schematics/ng-update/steps/migrate-templates.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_component_templates_1 = require("../../utils/templates/get-component-templates");
+const templates_1 = require("../constants/templates");
+const elements_1 = require("../../utils/templates/elements");
+const devkit_file_system_1 = require("ng-morph/project/classes/devkit-file-system");
+const ng_component_input_manipulations_1 = require("../../utils/templates/ng-component-input-manipulations");
+const template_resource_1 = require("../../utils/templates/template-resource");
+const ng_morph_1 = require("ng-morph");
+const START_TAG_OFFSET = 1;
+const END_TAG_OFFSET = 2;
+function migrateTemplates(tree) {
+    const templateResources = get_component_templates_1.getComponentTemplates('**/**');
+    const fileSystem = new devkit_file_system_1.DevkitFileSystem(tree);
+    templateResources.forEach((resource) => {
+        const path = fileSystem.resolve(template_resource_1.getPathFromTemplateResource(resource));
+        const template = template_resource_1.getTemplateFromTemplateResource(resource, fileSystem);
+        const recorder = fileSystem.edit(path);
+        const offset = template_resource_1.getTemplateOffset(resource);
+        replaceTags(template, recorder, offset);
+        replaceAttrs(template, recorder, offset);
+        replaceAttrsByDirective(fileSystem, resource);
+        /**
+         * We should update virtual file tree
+         * otherwise all following ng-morph commands will overwrite all previous template manipulations
+         * */
+        fileSystem.commitEdits();
+        ng_morph_1.saveActiveProject();
+        ng_morph_1.setActiveProject(ng_morph_1.createProject(fileSystem.tree, '/', '**/**'));
+    });
+}
+exports.migrateTemplates = migrateTemplates;
+function replaceAttrsByDirective(fileSystem, templateResource) {
+    templates_1.ATTR_TO_DIRECTIVE.forEach(({ componentSelector, directiveModule, directive, inputProperty }) => {
+        ng_component_input_manipulations_1.replaceInputPropertyByDirective({
+            componentSelector,
+            directiveModule,
+            directive,
+            inputProperty,
+            fileSystem,
+            templateResource,
+        });
+    });
+}
+function replaceAttrs(template, recorder, templateOffset = 0) {
+    templates_1.ATTRS_TO_REPLACE.forEach(({ from, to }) => {
+        const offsets = [
+            ...elements_1.findAttributeOnElementWithTag(template, from.attrName, from.withTagNames || []),
+            ...elements_1.findAttributeOnElementWithAttrs(template, from.attrName, from.withAttrsNames || []),
+        ];
+        offsets.forEach(offset => {
+            recorder.remove(offset + templateOffset, from.attrName.length + (to.attrName.length ? 0 : 1));
+            recorder.insertRight(offset + templateOffset, to.attrName);
+        });
+    });
+}
+function replaceTags(template, recorder, templateOffset = 0) {
+    templates_1.TAGS_TO_REPLACE.forEach(({ from, to, addAttributes }) => {
+        const elements = elements_1.findElementsByTagName(template, from);
+        elements.forEach(({ sourceCodeLocation }) => {
+            var _a;
+            if (sourceCodeLocation) {
+                const startTagOffset = sourceCodeLocation.startTag.startOffset;
+                const endTagOffset = (_a = sourceCodeLocation.endTag) === null || _a === void 0 ? void 0 : _a.startOffset;
+                if (endTagOffset) {
+                    recorder.remove(endTagOffset + templateOffset + END_TAG_OFFSET, from.length);
+                    recorder.insertRight(endTagOffset + templateOffset + END_TAG_OFFSET, to);
+                }
+                recorder.remove(startTagOffset + templateOffset + START_TAG_OFFSET, from.length);
+                recorder.insertRight(startTagOffset + templateOffset + START_TAG_OFFSET, `${to} ${addAttributes.join(' ')}`);
+            }
+        });
+    });
+}

package/schematics/ng-update/steps/remove-module.d.ts

@@ -0,0 +1,2 @@
+export declare function removeModules(): void;
+export declare function removeModule(name: string, moduleSpecifier: string): void;

package/schematics/ng-update/steps/remove-module.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ng_morph_1 = require("ng-morph");
+const get_named_import_references_1 = require("../../utils/get-named-import-references");
+const import_manipulations_1 = require("../../utils/import-manipulations");
+const modules_1 = require("../constants/modules");
+function removeModules() {
+    modules_1.REMOVED_MODULES.forEach(({ name, moduleSpecifier }) => removeModule(name, moduleSpecifier));
+}
+exports.removeModules = removeModules;
+function removeModule(name, moduleSpecifier) {
+    const references = get_named_import_references_1.getNamedImportReferences(name, moduleSpecifier);
+    references.forEach(ref => {
+        const parent = ref.getParent();
+        if (ng_morph_1.Node.isImportSpecifier(parent)) {
+            import_manipulations_1.removeImport(parent);
+        }
+        else if (ng_morph_1.Node.isArrayLiteralExpression(parent)) {
+            const index = parent.getElements().findIndex(el => el.getText() === name);
+            parent.removeElement(index);
+        }
+    });
+}
+exports.removeModule = removeModule;

package/schematics/ng-update/steps/replace-const.js

@@ -11,7 +11,7 @@ function replaceConsts() {
 exports.replaceConsts = replaceConsts;
 function replaceConst({ from, to }) {
     const references = get_named_import_references_1.getNamedImportReferences(from.name, from.moduleSpecifier);
-    for (let ref of references) {
+    references.forEach(ref => {
         const parent = ref.getParent();
         if (ng_morph_1.Node.isImportSpecifier(parent)) {
             import_manipulations_1.removeImport(parent);
@@ -20,6 +20,6 @@ function replaceConst({ from, to }) {
         else {
             ref === null || ref === void 0 ? void 0 : ref.replaceWithText(to.name);
         }
-    }
+    });
 }
 exports.replaceConst = replaceConst;

package/schematics/utils/add-unique-import.js

@@ -16,7 +16,7 @@ function addUniqueImport(filePath, namedImport, moduleSpecifier) {
         const modules = existingDeclaration[0]
             .getNamedImports()
             .map(namedImport => namedImport.getText());
-        ng_morph_1.editImports(existingDeclaration, () => ({
+        ng_morph_1.editImports(existingDeclaration[0], () => ({
             namedImports: [...modules, namedImport],
         }));
         return;

package/schematics/utils/angular/ng-component.d.ts

@@ -0,0 +1,3 @@
+import { ClassDeclaration, Pattern, Query } from 'ng-morph';
+import { StructureType } from 'ng-morph/utils/types/structure-type';
+export declare function getNgComponents(pattern: Pattern, query?: Query<Omit<StructureType<ClassDeclaration>, 'kind'>>): ClassDeclaration[];

package/schematics/utils/angular/ng-component.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ng_morph_1 = require("ng-morph");
+function getNgComponents(pattern, query) {
+    return ng_morph_1.getClasses(pattern, query).filter(declaration => !!declaration.getDecorator('Component'));
+}
+exports.getNgComponents = getNgComponents;

package/schematics/utils/angular/ng-module.d.ts

@@ -0,0 +1,7 @@
+import { ClassDeclaration, Pattern, Query } from 'ng-morph';
+import { StructureType } from 'ng-morph/utils/types/structure-type';
+export declare function getNgModules(pattern: Pattern, query?: Query<Omit<StructureType<ClassDeclaration>, 'kind'>>): ClassDeclaration[];
+/**
+ * Find NgModule where the component was declared.
+ */
+export declare function findNgModule(ngComponent: ClassDeclaration): ClassDeclaration | null;

package/schematics/utils/angular/ng-module.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ng_morph_1 = require("ng-morph");
+function getNgModules(pattern, query) {
+    return ng_morph_1.getClasses(pattern, query).filter(declaration => !!declaration.getDecorator('NgModule'));
+}
+exports.getNgModules = getNgModules;
+/**
+ * Find NgModule where the component was declared.
+ */
+function findNgModule(ngComponent) {
+    const allNgModules = getNgModules('**/**');
+    return (allNgModules.find(module => {
+        const moduleFile = module.getSourceFile();
+        const imports = ng_morph_1.getImports(moduleFile.getFilePath(), {
+            namedImports: ngComponent.getName(),
+        });
+        return imports.some(i => i.getModuleSpecifierSourceFile() === ngComponent.getSourceFile());
+    }) || null);
+}
+exports.findNgModule = findNgModule;

package/schematics/utils/templates/elements.d.ts

@@ -0,0 +1,21 @@
+import { Element } from 'parse5';
+export declare function findElementsByTagName(html: string, tagName: string): Element[];
+/**
+ * Parses a HTML fragment and traverses all AST nodes in order find elements that
+ * include the specified attribute.
+ */
+export declare function findElementsWithAttribute(html: string, attributeName: string): Element[];
+/**
+ * Finds elements with explicit tag names that also contain the specified attribute. Returns the
+ * attribute start offset based on the specified HTML.
+ */
+export declare function findAttributeOnElementWithTag(html: string, name: string, tagNames: string[], filterFn?: (element: Element) => boolean): number[];
+/**
+ * Finds elements that contain the given attribute and contain at least one of the other
+ * specified attributes. Returns the primary attribute's start offset based on the specified HTML.
+ */
+export declare function findAttributeOnElementWithAttrs(html: string, name: string, attrs: string[], filterFn?: (element: Element) => boolean): number[];
+/** Shorthand function that checks if the specified element contains the given attribute. */
+export declare function hasElementAttribute(element: Element, attributeName: string): boolean;
+/** Gets the start offset of the given attribute from a Parse5 element. */
+export declare function getStartOffsetOfAttribute(element: Element, attributeName: string): number;

package/schematics/utils/templates/elements.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parse5_1 = require("parse5");
+const ALWAYS_TRUE_HANDLER = () => true;
+function findElementsByTagName(html, tagName) {
+    const document = parse5_1.parseFragment(html, { sourceCodeLocationInfo: true });
+    const elements = [];
+    const visitNodes = (nodes) => {
+        nodes.forEach(n => {
+            const node = n;
+            if (node.childNodes) {
+                visitNodes(node.childNodes);
+            }
+            if (node.tagName === tagName) {
+                elements.push(node);
+            }
+        });
+    };
+    visitNodes(document.childNodes);
+    return elements;
+}
+exports.findElementsByTagName = findElementsByTagName;
+/**
+ * Parses a HTML fragment and traverses all AST nodes in order find elements that
+ * include the specified attribute.
+ */
+function findElementsWithAttribute(html, attributeName) {
+    const document = parse5_1.parseFragment(html, { sourceCodeLocationInfo: true });
+    const elements = [];
+    const visitNodes = (nodes) => {
+        nodes.forEach(n => {
+            var _a;
+            const node = n;
+            if (node.childNodes) {
+                visitNodes(node.childNodes);
+            }
+            if ((_a = node.attrs) === null || _a === void 0 ? void 0 : _a.some(attr => attr.name === attributeName.toLowerCase())) {
+                elements.push(node);
+            }
+        });
+    };
+    visitNodes(document.childNodes);
+    return elements;
+}
+exports.findElementsWithAttribute = findElementsWithAttribute;
+/**
+ * Finds elements with explicit tag names that also contain the specified attribute. Returns the
+ * attribute start offset based on the specified HTML.
+ */
+function findAttributeOnElementWithTag(html, name, tagNames, filterFn = ALWAYS_TRUE_HANDLER) {
+    return findElementsWithAttribute(html, name)
+        .filter(element => tagNames.includes(element.tagName) && filterFn(element))
+        .map(element => getStartOffsetOfAttribute(element, name));
+}
+exports.findAttributeOnElementWithTag = findAttributeOnElementWithTag;
+/**
+ * Finds elements that contain the given attribute and contain at least one of the other
+ * specified attributes. Returns the primary attribute's start offset based on the specified HTML.
+ */
+function findAttributeOnElementWithAttrs(html, name, attrs, filterFn = ALWAYS_TRUE_HANDLER) {
+    return findElementsWithAttribute(html, name)
+        .filter(element => attrs.some(attr => hasElementAttribute(element, attr)) &&
+        filterFn(element))
+        .map(element => getStartOffsetOfAttribute(element, name));
+}
+exports.findAttributeOnElementWithAttrs = findAttributeOnElementWithAttrs;
+/** Shorthand function that checks if the specified element contains the given attribute. */
+function hasElementAttribute(element, attributeName) {
+    return (element.attrs &&
+        element.attrs.some(attr => attr.name === attributeName.toLowerCase()));
+}
+exports.hasElementAttribute = hasElementAttribute;
+/** Gets the start offset of the given attribute from a Parse5 element. */
+function getStartOffsetOfAttribute(element, attributeName) {
+    var _a, _b;
+    return ((((_a = element.sourceCodeLocation) === null || _a === void 0 ? void 0 : _a.attrs) && ((_b = element.sourceCodeLocation.attrs[attributeName.toLowerCase()]) === null || _b === void 0 ? void 0 : _b.startOffset)) ||
+        0);
+}
+exports.getStartOffsetOfAttribute = getStartOffsetOfAttribute;

package/schematics/utils/templates/get-component-templates.d.ts

@@ -0,0 +1,4 @@
+import { ClassDeclaration, Pattern, Query } from 'ng-morph';
+import { StructureType } from 'ng-morph/utils/types/structure-type';
+import { TemplateResource } from '../../ng-update/interfaces/template-resourse';
+export declare function getComponentTemplates(pattern: Pattern, query?: Query<Omit<StructureType<ClassDeclaration>, 'kind'>>): TemplateResource[];

package/schematics/utils/templates/get-component-templates.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const ng_morph_1 = require("ng-morph");
+const path = tslib_1.__importStar(require("path"));
+function getComponentTemplates(pattern, query) {
+    return ng_morph_1.getClasses(pattern, query)
+        .map(declaration => declaration.getDecorator('Component'))
+        .filter((decorator) => !!decorator)
+        .map(decoratorToTemplateResource);
+}
+exports.getComponentTemplates = getComponentTemplates;
+function decoratorToTemplateResource(decorator) {
+    var _a, _b, _c;
+    const [metadata] = decorator.getArguments();
+    const templateUrl = metadata.getProperty('templateUrl');
+    const template = metadata.getProperty('template');
+    const componentPath = decorator.getSourceFile().getFilePath();
+    if (templateUrl) {
+        const templatePath = path.parse(((_a = templateUrl === null || templateUrl === void 0 ? void 0 : templateUrl.getInitializer()) === null || _a === void 0 ? void 0 : _a.getText().replace(/['"]/g, '')) || '');
+        return {
+            componentPath,
+            templatePath: getFullTemplatePath(templatePath, path.parse(componentPath)),
+        };
+    }
+    else {
+        return {
+            componentPath,
+            template: ((_b = template.getInitializer()) === null || _b === void 0 ? void 0 : _b.getText()) || '',
+            offset: ((_c = template.getInitializer()) === null || _c === void 0 ? void 0 : _c.getStart()) || 0,
+        };
+    }
+}
+function getFullTemplatePath(templatePath, componentPath) {
+    return path.join(componentPath.dir, templatePath.dir, templatePath.name + templatePath.ext);
+}

package/schematics/utils/templates/ng-component-input-manipulations.d.ts

@@ -0,0 +1,76 @@
+import { DevkitFileSystem } from 'ng-morph/project/classes/devkit-file-system';
+import { Element } from 'parse5';
+import { TemplateResource } from '../../ng-update/interfaces/template-resourse';
+/**
+ * Replace component input property by new value
+ * ___
+ * Example:
+ * 1. Before
+ * ```html
+ * <tui-input-slider secondary="123"></tui-input-slider>
+ * ```
+ * 2. Execute
+ * ```ts
+ * const wasModified = replaceInputProperty({
+ *      templateResource,
+ *      fileSystem,
+ *      componentSelector: 'tui-input-slider',
+ *      from: 'secondary',
+ *      to: 'tuiTextfieldCustomContent',
+ * });
+ * ```
+ * 3. After
+ * ```html
+ * <tui-input-slider tuiTextfieldCustomContent="123"></tui-input-slider>
+ * ```
+ * ___
+ * @return true if something was changed
+ */
+export declare function replaceInputProperty({ templateResource, fileSystem, componentSelector, from, to, newValue, filterFn, }: {
+    templateResource: TemplateResource;
+    fileSystem: DevkitFileSystem;
+    componentSelector: string | string[];
+    from: string;
+    to: string;
+    newValue?: string;
+    filterFn?: (element: Element) => boolean;
+}): boolean;
+/**
+ * @example
+ * // 10 symbols before property `size` and string `size="s"` has 8-symbols length
+ * const template = '<tui-card size="s"></tui-card>';
+ *
+ * getInputPropertyOffsets(template, 'size', ['tui-card']) // [[10, 18]]
+ */
+export declare function getInputPropertyOffsets(html: string, attrName: string, tags: string[], filterFn?: (element: Element) => boolean): [number, number][];
+/**
+ * @example
+ * // `<tui-card size="` has 16-symbols length
+ * const template = '<tui-card size="xl"></tui-card>';
+ *
+ * getInputPropertyValueOffsets(template, 'size', ['tui-card']) // [ [16, 18] ]
+ */
+export declare function getInputPropertyValueOffsets(template: string, attrName: string, tags: string[]): [number, number][];
+export declare function replaceInputPropertyByDirective({ templateResource, fileSystem, componentSelector, inputProperty, directive, directiveModule, }: {
+    templateResource: TemplateResource;
+    fileSystem: DevkitFileSystem;
+    componentSelector: string | string[];
+    inputProperty: string;
+    directive: string;
+    directiveModule?: {
+        name: string;
+        moduleSpecifier: string;
+    };
+}): void;
+/**
+ * After removing property from the tag (which uses multi lines inside template) it can leave redundant space.
+ * It is not critical because html is valid even with this extra space.
+ * TODO: Find a way to fix it
+ */
+export declare function removeInputProperty({ templateResource, fileSystem, componentSelector, inputProperty, filterFn, }: {
+    templateResource: TemplateResource;
+    fileSystem: DevkitFileSystem;
+    componentSelector: string;
+    inputProperty: string;
+    filterFn?: (element: Element) => boolean;
+}): void;