@taiga-ui/cdk 2.37.1 → 2.40.0

package/schematics/ng-add/steps/add-taiga-icons.d.ts

@@ -0,0 +1,5 @@
+import { workspaces } from '@angular-devkit/core';
+import { Rule } from '@angular-devkit/schematics';
+import { Schema } from '../schema';
+export declare function addTaigaIcons(options: Schema): Rule;
+export declare function addTaigaStylesToAngularJson(workspace: workspaces.WorkspaceDefinition, project: workspaces.ProjectDefinition): Rule;

package/schematics/ng-add/steps/add-taiga-icons.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const workspace_1 = require("@schematics/angular/utility/workspace");
+const workspace_2 = require("@schematics/angular/utility/workspace");
+const get_project_1 = require("../../utils/get-project");
+const get_project_target_options_1 = require("../../utils/get-project-target-options");
+const ICON_ASSETS = {
+    glob: '**/*',
+    input: 'node_modules/@taiga-ui/icons/src',
+    output: 'assets/taiga-ui/icons',
+};
+function addTaigaIcons(options) {
+    return (tree) => __awaiter(this, void 0, void 0, function* () {
+        const workspace = yield workspace_2.getWorkspace(tree);
+        const project = get_project_1.getProject(options, workspace);
+        return addTaigaStylesToAngularJson(workspace, project);
+    });
+}
+exports.addTaigaIcons = addTaigaIcons;
+function addTaigaStylesToAngularJson(workspace, project) {
+    const targetOptions = get_project_target_options_1.getProjectTargetOptions(project, 'build');
+    const assets = targetOptions.assets;
+    if (!assets) {
+        targetOptions.assets = [ICON_ASSETS];
+    }
+    else {
+        targetOptions.assets = [...assets, ICON_ASSETS];
+    }
+    return workspace_1.updateWorkspace(workspace);
+}
+exports.addTaigaStylesToAngularJson = addTaigaStylesToAngularJson;

package/schematics/ng-add/steps/add-taiga-modules.d.ts

@@ -0,0 +1,3 @@
+import { Rule } from '@angular-devkit/schematics';
+import { Schema } from '../schema';
+export declare function addTaigaModules(options: Schema): Rule;

package/schematics/ng-add/steps/add-taiga-modules.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const workspace_1 = require("@schematics/angular/utility/workspace");
+const ng_morph_1 = require("ng-morph");
+const get_project_1 = require("../../utils/get-project");
+const get_project_target_options_1 = require("../../utils/get-project-target-options");
+const modules_1 = require("../constants/modules");
+function addTaigaModules(options) {
+    return (tree, context) => __awaiter(this, void 0, void 0, function* () {
+        const workspace = yield workspace_1.getWorkspace(tree);
+        const project = get_project_1.getProject(options, workspace);
+        const buildOptions = get_project_target_options_1.getProjectTargetOptions(project, 'build');
+        ng_morph_1.setActiveProject(ng_morph_1.createProject(tree, '/', ['**/*.ts', '**/*.json']));
+        const mainModule = ng_morph_1.getMainModule(buildOptions.main);
+        addTuiModules(mainModule, options, context);
+        addTuiProviders(mainModule, options);
+        ng_morph_1.saveActiveProject();
+    });
+}
+exports.addTaigaModules = addTaigaModules;
+function addTuiModules(mainModule, options, context) {
+    const modules = [
+        ...modules_1.MAIN_MODULES,
+        ...(options.addDialogsModule ? modules_1.DIALOG_MODULES : []),
+        ...(options.addNotificationsModule ? modules_1.NOTIFICATION_MODULES : []),
+    ];
+    const mainModulePath = mainModule.getSourceFile().getFilePath();
+    modules.forEach(module => {
+        ng_morph_1.addImportToNgModule(mainModule, module.name, { unique: true });
+        addUniqueImport(mainModulePath, module.name, module.packageName);
+    });
+    context.logger.info(`${modules.map(module => module.name)} was added to ${mainModulePath}`);
+}
+function addTuiProviders(mainModule, options) {
+    if (!options.addSanitizer) {
+        return;
+    }
+    ng_morph_1.addProviderToNgModule(mainModule, '{provide: TUI_SANITIZER, useClass: NgDompurifySanitizer}', { unique: true });
+    modules_1.SANITIZER_MODULES.forEach(module => {
+        addUniqueImport(mainModule.getSourceFile().getFilePath(), module.name, module.packageName);
+    });
+}
+function addUniqueImport(filePath, namedImport, packageName) {
+    const existingNamedImport = ng_morph_1.getImports(filePath, {
+        namedImports: namedImport,
+        moduleSpecifier: packageName,
+    });
+    if (existingNamedImport.length) {
+        return;
+    }
+    const existingDeclaration = ng_morph_1.getImports(filePath, {
+        moduleSpecifier: packageName,
+    });
+    if (existingDeclaration.length) {
+        const modules = existingDeclaration[0]
+            .getNamedImports()
+            .map(namedImport => namedImport.getText());
+        ng_morph_1.editImports(existingDeclaration, () => ({
+            namedImports: [...modules, namedImport],
+        }));
+        return;
+    }
+    ng_morph_1.addImports(filePath, {
+        moduleSpecifier: packageName,
+        namedImports: [namedImport],
+    });
+}

package/schematics/ng-add/steps/add-taiga-styles.d.ts

@@ -0,0 +1,5 @@
+import { workspaces } from '@angular-devkit/core';
+import { Rule } from '@angular-devkit/schematics';
+import { Schema } from '../schema';
+export declare function addTaigaStyles(options: Schema): Rule;
+export declare function addTaigaStylesToAngularJson(workspace: workspaces.WorkspaceDefinition, project: workspaces.ProjectDefinition): Rule;

package/schematics/ng-add/steps/add-taiga-styles.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const workspace_1 = require("@schematics/angular/utility/workspace");
+const workspace_2 = require("@schematics/angular/utility/workspace");
+const get_project_1 = require("../../utils/get-project");
+const get_project_target_options_1 = require("../../utils/get-project-target-options");
+const TAIGA_GLOBAL_STYLE = 'node_modules/@taiga-ui/core/styles/taiga-ui-global.less';
+const TAIGA_THEME_STYLE = 'node_modules/@taiga-ui/core/styles/taiga-ui-theme.less';
+function addTaigaStyles(options) {
+    return (tree) => __awaiter(this, void 0, void 0, function* () {
+        const workspace = yield workspace_2.getWorkspace(tree);
+        const project = get_project_1.getProject(options, workspace);
+        return addTaigaStylesToAngularJson(workspace, project);
+    });
+}
+exports.addTaigaStyles = addTaigaStyles;
+function addTaigaStylesToAngularJson(workspace, project) {
+    const targetOptions = get_project_target_options_1.getProjectTargetOptions(project, 'build');
+    const styles = targetOptions.styles;
+    const taigaStyles = [TAIGA_GLOBAL_STYLE, TAIGA_THEME_STYLE];
+    if (!styles) {
+        targetOptions.styles = taigaStyles;
+    }
+    else {
+        targetOptions.styles = Array.from(new Set([...taigaStyles, ...styles]));
+    }
+    return workspace_1.updateWorkspace(workspace);
+}
+exports.addTaigaStylesToAngularJson = addTaigaStylesToAngularJson;

package/schematics/ng-add/steps/wrap-with-tui-root.d.ts

@@ -0,0 +1,3 @@
+import { Rule } from '@angular-devkit/schematics';
+import { Schema } from '../schema';
+export declare function wrapWithTuiRootComponent(options: Schema): Rule;

package/schematics/ng-add/steps/wrap-with-tui-root.js

@@ -0,0 +1,82 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const workspace_1 = require("@schematics/angular/utility/workspace");
+const ng_morph_1 = require("ng-morph");
+const get_project_1 = require("../../utils/get-project");
+const get_project_target_options_1 = require("../../utils/get-project-target-options");
+function wrapWithTuiRootComponent(options) {
+    return (tree, context) => __awaiter(this, void 0, void 0, function* () {
+        const workspace = yield workspace_1.getWorkspace(tree);
+        const project = get_project_1.getProject(options, workspace);
+        const buildOptions = get_project_target_options_1.getProjectTargetOptions(project, 'build');
+        const appTemplatePath = getAppTemplatePath(tree, buildOptions.main);
+        if (!appTemplatePath) {
+            context.logger.error('Could not find the default main template file for this project.');
+            context.logger.info('Consider manually wrapping content of your app with tui-root');
+            context.logger.info('More information at https://taiga-ui.dev/getting-started');
+            return;
+        }
+        addTuiRootComponent(appTemplatePath, context, tree);
+    });
+}
+exports.wrapWithTuiRootComponent = wrapWithTuiRootComponent;
+function addTuiRootComponent(filePath, context, tree) {
+    const buffer = tree.read(filePath);
+    if (!buffer) {
+        context.logger.error(`Could not read the default template file within the project ${filePath}`);
+        context.logger.info('Consider manually wrapping content of your app with tui-root');
+        return;
+    }
+    const htmlContent = buffer.toString();
+    const openTag = '<tui-root>' + '\n';
+    const closeTag = '\n' + '</tui-root>';
+    if (htmlContent.includes(openTag)) {
+        return;
+    }
+    const recorder = tree.beginUpdate(filePath);
+    recorder.insertLeft(0, openTag);
+    recorder.insertLeft(htmlContent.length, closeTag);
+    tree.commitUpdate(recorder);
+    context.logger.info(`Content of the app was wrapped with tui-root component in ${filePath}`);
+}
+function getAppTemplatePath(tree, mainPath) {
+    ng_morph_1.setActiveProject(ng_morph_1.createProject(tree, '/', ['**/*.ts', '**/*.json']));
+    const mainModule = ng_morph_1.getMainModule(mainPath);
+    const mainInitializer = getInitializer(mainModule, 'NgModule', 'declarations');
+    if (!ng_morph_1.Node.isArrayLiteralExpression(mainInitializer)) {
+        return;
+    }
+    const appIdentifier = mainInitializer.getElements()[0];
+    const appComponent = appIdentifier.getDefinitionNodes()[0];
+    const templateInitializer = getInitializer(appComponent, 'Component', 'templateUrl');
+    const appComponentPath = appComponent.getSourceFile().getFilePath().split('/');
+    const templateUrlPath = `${appComponentPath
+        .splice(0, appComponentPath.length - 1)
+        .join('/')}/${templateInitializer === null || templateInitializer === void 0 ? void 0 : templateInitializer.getText().replace(/['"]/g, '')}`;
+    ng_morph_1.saveActiveProject();
+    return templateUrlPath;
+}
+function getInitializer(classDeclaration, decoratorName, propertyName) {
+    const decorator = classDeclaration.getDecorator(decoratorName);
+    if (!decorator) {
+        return;
+    }
+    const [metadata] = decorator.getArguments();
+    if (!ng_morph_1.Node.isObjectLiteralExpression(metadata)) {
+        return;
+    }
+    const property = metadata.getProperty(propertyName);
+    if (!ng_morph_1.Node.isPropertyAssignment(property)) {
+        return;
+    }
+    return property.getInitializer();
+}

package/schematics/ng-update/index.d.ts

@@ -0,0 +1,3 @@
+import { SchematicContext } from '@angular-devkit/schematics';
+import { Schema } from '../ng-add/schema';
+export declare function updateToV3(_: Schema): (_: any, context: SchematicContext) => Promise<void>;

package/schematics/ng-update/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const versions_1 = require("../ng-add/constants/versions");
+function updateToV3(_) {
+    return (_, context) => __awaiter(this, void 0, void 0, function* () {
+        context.logger.info(`taiga packages will be updated to ${versions_1.TAIGA_VERSION}`);
+    });
+}
+exports.updateToV3 = updateToV3;

package/schematics/utils/get-project-target-options.d.ts

@@ -0,0 +1,2 @@
+import { JsonArray, JsonObject, workspaces } from '@angular-devkit/core';
+export declare function getProjectTargetOptions(project: workspaces.ProjectDefinition, buildTarget: string): Record<string, string | number | boolean | JsonArray | JsonObject | undefined | null>;

package/schematics/utils/get-project-target-options.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schematics_1 = require("@angular-devkit/schematics");
+function getProjectTargetOptions(project, buildTarget) {
+    var _a;
+    const buildTargetObject = (_a = project.targets) === null || _a === void 0 ? void 0 : _a.get(buildTarget);
+    if (buildTargetObject && buildTargetObject.options) {
+        return buildTargetObject.options;
+    }
+    throw new schematics_1.SchematicsException(`Cannot determine project target configuration for: ${buildTarget}.`);
+}
+exports.getProjectTargetOptions = getProjectTargetOptions;

package/schematics/utils/get-project.d.ts

@@ -0,0 +1,3 @@
+import { workspaces } from '@angular-devkit/core';
+import { Schema } from '../ng-add/schema';
+export declare function getProject(options: Schema, workspace: workspaces.WorkspaceDefinition): workspaces.ProjectDefinition;

package/schematics/utils/get-project.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schematics_1 = require("@angular-devkit/schematics");
+function getProject(options, workspace) {
+    const projectName = options.project || workspace.extensions.defaultProject.toString();
+    const project = workspace.projects.get(projectName);
+    if (!project) {
+        throw new schematics_1.SchematicsException(`Unable to find project '${projectName}' in the workspace`);
+    }
+    return project;
+}
+exports.getProject = getProject;

package/services/obscured.service.d.ts

@@ -6,7 +6,7 @@ import { TuiParentsScrollService } from './parents-scroll.service';
  * and polling with set interval, returns either null or an array
  * of elements that overlap given element edges
  */
-export declare class TuiObscuredService extends Observable<null | ReadonlyArray<Element>> {
+export declare class TuiObscuredService extends Observable<null | readonly Element[]> {
     private readonly obscured$;
     constructor(parentsScroll$: TuiParentsScrollService, { nativeElement }: ElementRef<Element>, ngZone: NgZone, windowRef: Window, destroy$: Observable<void>, animationFrame$: Observable<number>);
 }

package/utils/dom/get-element-obscurers.d.ts

@@ -3,4 +3,4 @@
  *
  * CAUTION: Empty array means element if offscreen i.e. covered by no elements, rather than not covered
  */
-export declare function getElementObscurers(element: Element): ReadonlyArray<Element> | null;
+export declare function getElementObscurers(element: Element): readonly Element[] | null;

package/utils/focus/move-focus.d.ts

@@ -5,4 +5,4 @@
  * @param elements array of focusable elements
  * @param step a step to move focus by, typically -1 or 1
  */
-export declare function moveFocus(currentIndex: number, elements: ReadonlyArray<HTMLElement>, step: number): void;
+export declare function moveFocus(currentIndex: number, elements: readonly HTMLElement[], step: number): void;

package/utils/miscellaneous/flat-length.d.ts

@@ -3,4 +3,4 @@
  *
  * @param array twi dimensional array
  */
-export declare function flatLength(array: ReadonlyArray<ReadonlyArray<unknown>>): number;
+export declare function flatLength(array: ReadonlyArray<readonly unknown[]>): number;

package/utils/miscellaneous/get-original-array-from-query-list.d.ts

@@ -5,4 +5,4 @@ import { QueryList } from '@angular/core';
  * @param queryList
  * @returns original array from {@link QueryList}.
  */
-export declare function getOriginalArrayFromQueryList<T>(queryList: QueryList<T>): ReadonlyArray<T>;
+export declare function getOriginalArrayFromQueryList<T>(queryList: QueryList<T>): readonly T[];

package/utils/miscellaneous/uniq-by.d.ts

@@ -1 +1 @@
-export declare function uniqBy<T extends object>(array: ReadonlyArray<T>, key: keyof T): ReadonlyArray<T>;
+export declare function uniqBy<T extends object>(array: readonly T[], key: keyof T): readonly T[];