@ui5/webcomponents-ngx 0.5.9-rc.4 → 0.5.9

package/schematics/add-dependencies/index.d.ts

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

package/schematics/add-dependencies/index.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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addDependencies = addDependencies;
+const workspace_1 = require("@schematics/angular/utility/workspace");
+const tasks_1 = require("@angular-devkit/schematics/tasks");
+const package_config_1 = require("../utils/package-config");
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore is needed because the package.json is not available at build time
+const package_json_1 = __importDefault(require("../../package.json"));
+const commonCssPackageName = '@sap-ui/common-css';
+const themingNgxPackageName = '@ui5/theming-ngx';
+function addDependencies(options) {
+    return (tree, context) => (0, workspace_1.updateWorkspace)(() => __awaiter(this, void 0, void 0, function* () {
+        if (options.commonCss.length && !(0, package_config_1.getPackageVersionFromPackageJson)(tree, commonCssPackageName)) {
+            (0, package_config_1.addPackageToPackageJson)(tree, commonCssPackageName, 'latest');
+        }
+        if (!(0, package_config_1.getPackageVersionFromPackageJson)(tree, themingNgxPackageName)) {
+            (0, package_config_1.addPackageToPackageJson)(tree, themingNgxPackageName, package_json_1.default.version);
+        }
+        const peerDependencies = Object.keys(package_json_1.default.peerDependencies).map((peerDependency) => ([peerDependency, package_json_1.default.peerDependencies[peerDependency]]));
+        for (const [peerDependency, version] of peerDependencies) {
+            if (!(0, package_config_1.getPackageVersionFromPackageJson)(tree, peerDependency)) {
+                (0, package_config_1.addPackageToPackageJson)(tree, peerDependency, version);
+            }
+        }
+        context.addTask(new tasks_1.NodePackageInstallTask());
+    }));
+}

package/schematics/add-i18n/index.d.ts

@@ -0,0 +1,8 @@
+import { Rule } from "@angular-devkit/schematics";
+interface I18nOptions {
+    useI18n: boolean;
+    project: string;
+    defaultLanguage: string;
+}
+export declare function addI18n(options: I18nOptions): Rule;
+export {};

package/schematics/add-i18n/index.js

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 });
+exports.addI18n = addI18n;
+const schematics_1 = require("@angular-devkit/schematics");
+const ts = __importStar(require("typescript"));
+const workspace_1 = require("@schematics/angular/utility/workspace");
+const change_1 = require("@schematics/angular/utility/change");
+const ng_ast_utils_1 = require("@schematics/angular/utility/ng-ast-utils");
+const ast_utils_1 = require("@schematics/angular/utility/ast-utils");
+const util_1 = require("@schematics/angular/utility/standalone/util");
+const get_project_definition_1 = require("../utils/get-project-definition");
+const project_main_file_1 = require("../utils/project-main-file");
+const getModuleDeclaration_1 = require("../utils/getModuleDeclaration");
+const getSourceFile_1 = require("../utils/getSourceFile");
+const find_providers_literal_1 = require("../utils/find-providers-literal");
+function addI18n(options) {
+    return (tree, context) => __awaiter(this, void 0, void 0, function* () {
+        return (0, workspace_1.updateWorkspace)((workspace) => __awaiter(this, void 0, void 0, function* () {
+            if (!options.useI18n) {
+                return;
+            }
+            const projectDefinition = (0, get_project_definition_1.getProjectDefinition)(workspace, options.project);
+            const update = addI18nModule(tree, projectDefinition, context, options);
+            const exportRecorder = tree.beginUpdate(update.file);
+            for (const change of update.changes) {
+                if (change instanceof change_1.InsertChange) {
+                    exportRecorder.insertLeft(change.pos, change.toAdd);
+                }
+            }
+            tree.commitUpdate(exportRecorder);
+        }));
+    });
+}
+function addI18nModule(tree, projectDefinition, context, options) {
+    var _a;
+    try {
+        return addModuleToNonStandaloneApp(tree, projectDefinition, context, options);
+    }
+    catch (e) {
+        if ((_a = e.message) === null || _a === void 0 ? void 0 : _a.includes('Bootstrap call not found')) {
+            return addModuleToStandaloneApp(tree, projectDefinition, context, options);
+        }
+        else {
+            throw e;
+        }
+    }
+}
+function rootProviderConfig(options) {
+    return `{
+      language: ${JSON.stringify(options.defaultLanguage)},
+      fetchDefaultLanguage: true,
+      bundle: {
+        name: 'app-root-i18n-bundle',
+        translations: {
+            // You can add your translations here. For more information please refer to the documentation.
+            [${JSON.stringify(options.defaultLanguage)}]: {
+                'app-root-title': 'Hello World!'
+            }
+        }
+      }
+    }`;
+}
+function addModuleToNonStandaloneApp(tree, projectDefinition, context, options) {
+    const appModulePath = (0, ng_ast_utils_1.getAppModulePath)(tree, (0, project_main_file_1.getProjectMainFile)(projectDefinition));
+    if (!appModulePath) {
+        throw new schematics_1.SchematicsException('Could not find root module for defined project.');
+    }
+    const appModuleSource = (0, getSourceFile_1.getSourceFile)(tree, appModulePath);
+    const i18nModule = (0, getModuleDeclaration_1.getModuleDeclaration)(appModuleSource, 'Ui5I18nModule');
+    const moduleConfig = `\nUi5I18nModule.forRoot(${rootProviderConfig(options)})`;
+    if (i18nModule) {
+        i18nModule.getChildren(appModuleSource);
+        const i18nModuleDecl = i18nModule.getFullText();
+        const appModuleContent = tree.readText(appModulePath).split(i18nModuleDecl).join(moduleConfig);
+        tree.overwrite(appModulePath, appModuleContent);
+        context.logger.info('Found previous Ui5I18nModule. Replaced with new one.');
+        return { changes: [], file: appModulePath };
+    }
+    const changes = [
+        ...(0, ast_utils_1.addImportToModule)(appModuleSource, appModulePath, moduleConfig, null),
+        (0, ast_utils_1.insertImport)(appModuleSource, appModulePath, 'Ui5I18nModule', '@ui5/webcomponents-ngx/i18n')
+    ];
+    return { changes, file: appModulePath };
+}
+function addModuleToStandaloneApp(tree, projectDefinition, context, options) {
+    const mainFile = (0, project_main_file_1.getProjectMainFile)(projectDefinition);
+    const mainFileSource = (0, getSourceFile_1.getSourceFile)(tree, mainFile);
+    const bootstrapCall = (0, util_1.findBootstrapApplicationCall)(tree, mainFile);
+    if (!bootstrapCall) {
+        throw new schematics_1.SchematicsException('Could not find bootstrap call in main.ts');
+    }
+    const providersLiteral = (0, find_providers_literal_1.findProvidersLiteral)(bootstrapCall);
+    const recorder = tree.beginUpdate(mainFile.toString());
+    const printer = ts.createPrinter();
+    const newProviderCall = ts.factory.createCallExpression(ts.factory.createIdentifier('i18nRootProviders'), undefined, [ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment('language', ts.factory.createStringLiteral(options.defaultLanguage)),
+            ts.factory.createPropertyAssignment('fetchDefaultLanguage', ts.factory.createTrue()),
+            ts.factory.createPropertyAssignment('bundle', ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment('name', ts.factory.createStringLiteral('app-root-i18n-bundle')),
+                ts.factory.createPropertyAssignment('translations', ts.factory.createObjectLiteralExpression([
+                    ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(options.defaultLanguage), ts.factory.createObjectLiteralExpression([
+                        ts.factory.createPropertyAssignment(ts.factory.createStringLiteral('app-root-title'), ts.factory.createStringLiteral('Hello World!')),
+                    ])),
+                ])),
+            ])),
+        ], true)]);
+    if (!providersLiteral) {
+        const bootstrapCallParams = [...bootstrapCall.arguments];
+        bootstrapCallParams[1] = ts.factory.createObjectLiteralExpression([createProvidersAssignment([newProviderCall])], true);
+        const newCall = ts.factory.updateCallExpression(bootstrapCall, bootstrapCall.expression, bootstrapCall.typeArguments, bootstrapCallParams);
+        recorder.remove(bootstrapCall.getStart(), bootstrapCall.getWidth());
+        recorder.insertRight(bootstrapCall.getStart(), printer.printNode(ts.EmitHint.Unspecified, newCall, mainFileSource));
+    }
+    else {
+        const existingUsageIndex = providersLiteral.elements.findIndex(el => ts.isCallExpression(el) && ts.isIdentifier(el.expression) && el.expression.escapedText === 'i18nRootProviders');
+        const newProvidersLiteral = ts.factory.createArrayLiteralExpression(providersLiteral.elements.filter((_el, i) => i !== existingUsageIndex).concat(newProviderCall));
+        if (existingUsageIndex !== -1) {
+            context.logger.info('Found previous i18nRootProviders call. Replaced with new one.');
+        }
+        recorder.remove(providersLiteral.getStart(), providersLiteral.getWidth());
+        recorder.insertRight(providersLiteral.getStart(), printer.printNode(ts.EmitHint.Unspecified, newProvidersLiteral, mainFileSource));
+    }
+    const importChange = (0, ast_utils_1.insertImport)(mainFileSource, mainFile, 'i18nRootProviders', '@ui5/webcomponents-ngx/i18n');
+    if (importChange instanceof change_1.InsertChange) {
+        recorder.insertLeft(importChange.pos, importChange.toAdd);
+    }
+    tree.commitUpdate(recorder);
+    return { changes: [], file: mainFile };
+}
+function createProvidersAssignment(elements = []) {
+    return ts.factory.createPropertyAssignment('providers', ts.factory.createArrayLiteralExpression(elements));
+}

package/schematics/add-styles/index.d.ts

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

package/schematics/add-styles/index.js

@@ -0,0 +1,34 @@
+"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 });
+exports.addStyles = addStyles;
+const workspace_1 = require("@schematics/angular/utility/workspace");
+const schematics_1 = require("@angular-devkit/schematics");
+function addStyles(options) {
+    return () => (0, workspace_1.updateWorkspace)((workspace) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const currentWorkspace = workspace.projects.get(options.project);
+        if (!currentWorkspace) {
+            throw new schematics_1.SchematicsException('Project with such name not found.');
+        }
+        const buildTargetOptions = (_a = currentWorkspace.targets.get('build')) === null || _a === void 0 ? void 0 : _a.options;
+        if (!buildTargetOptions) {
+            throw new schematics_1.SchematicsException('Could not find build target options for defined project.');
+        }
+        let styles = (buildTargetOptions['styles'] || []);
+        styles = styles.filter(style => (typeof style === 'string' && !style.startsWith('node_modules/@sap-ui/common-css') ||
+            typeof style !== 'string' && !style.input.startsWith('node_modules/@sap-ui/common-css')));
+        options.commonCss.forEach((style) => {
+            styles.push(`node_modules/@sap-ui/common-css/dist/${style}.css`);
+        });
+        buildTargetOptions['styles'] = styles;
+    }));
+}

package/schematics/add-theming/add-theming-module.d.ts

@@ -0,0 +1,8 @@
+import { SchematicContext, Tree } from "@angular-devkit/schematics";
+import { ProjectDefinition } from "@schematics/angular/utility";
+import { Schema } from '../schema';
+import { Change } from "@schematics/angular/utility/change";
+export declare function addThemingModule(host: Tree, project: ProjectDefinition, context: SchematicContext, options: Schema): {
+    changes: Change[];
+    file: string;
+};

package/schematics/add-theming/add-theming-module.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addThemingModule = addThemingModule;
+const schematics_1 = require("@angular-devkit/schematics");
+const ng_ast_utils_1 = require("@schematics/angular/utility/ng-ast-utils");
+const ast_utils_1 = require("@schematics/angular/utility/ast-utils");
+const getModuleDeclaration_1 = require("../utils/getModuleDeclaration");
+const project_main_file_1 = require("../utils/project-main-file");
+const util_1 = require("@schematics/angular/utility/standalone/util");
+// import {
+//   addModuleImportToStandaloneBootstrap,
+//   findBootstrapApplicationCall
+// } from "@schematics/angular/private/standalone";
+// import * as ts from "typescript";
+// import {findImportProvidersFromCall} from "../utils/find-import-providers-from-call";
+const getSourceFile_1 = require("../utils/getSourceFile");
+function addThemingModule(host, project, context, options) {
+    var _a;
+    try {
+        return addModuleToNonStandaloneApp(host, project, context, options);
+    }
+    catch (e) {
+        if ((_a = e.message) === null || _a === void 0 ? void 0 : _a.includes('Bootstrap call not found')) {
+            return addModuleToStandaloneApp(host, project);
+        }
+        else {
+            throw e;
+        }
+    }
+}
+function addModuleToNonStandaloneApp(host, project, context, options) {
+    const appModulePath = (0, ng_ast_utils_1.getAppModulePath)(host, (0, project_main_file_1.getProjectMainFile)(project));
+    if (!appModulePath) {
+        throw new schematics_1.SchematicsException('Could not find root module for defined project.');
+    }
+    const appModuleSource = (0, getSourceFile_1.getSourceFile)(host, appModulePath);
+    const themingModule = (0, getModuleDeclaration_1.getModuleDeclaration)(appModuleSource, 'Ui5ThemingModule');
+    if (themingModule) {
+        themingModule.getChildren(appModuleSource);
+        const themingModuleDecl = themingModule.getFullText();
+        const appModuleContent = host.readText(appModulePath).split(themingModuleDecl).join(`\nUi5ThemingModule.forRoot({defaultTheme: '${options.defaultTheme}'})`);
+        host.overwrite(appModulePath, appModuleContent);
+        context.logger.info('Found previous Ui5ThemingModule. Replaced with new one.');
+        return { changes: [], file: appModulePath };
+    }
+    const changes = [
+        ...(0, ast_utils_1.addImportToModule)(appModuleSource, appModulePath, `Ui5ThemingModule.forRoot({defaultTheme: '${options.defaultTheme}'})`, '@ui5/theming-ngx')
+    ];
+    return { changes, file: appModulePath };
+}
+function addModuleToStandaloneApp(host, project) {
+    const mainFile = (0, project_main_file_1.getProjectMainFile)(project);
+    const bootstrapCall = (0, util_1.findBootstrapApplicationCall)(host, mainFile);
+    if (!bootstrapCall) {
+        throw new schematics_1.SchematicsException('Could not find bootstrap call in main.ts');
+    }
+    // const themingModuleWithDefaultTheme = `Ui5ThemingModule.forRoot({ defaultTheme: '${options.defaultTheme}' })`;
+    // const imports = findImportProvidersFromCall(bootstrapCall);
+    // if (imports) {
+    //   const themingModuleImport = imports.arguments.find(arg => ts.isCallExpression(arg) && ts.isPropertyAccessExpression(arg.expression) && ts.isIdentifier(arg.expression.expression) && arg.expression.expression.text === 'Ui5ThemingModule');
+    //   if (themingModuleImport) {
+    //     const oldContent = host.readText(mainFile);
+    //     const newContent = oldContent.split(themingModuleImport.getFullText()).join(themingModuleWithDefaultTheme);
+    //     host.overwrite(mainFile, newContent);
+    //     context.logger.info('Found previous Ui5ThemingModule. Replaced with new one.');
+    //     return {changes: [], file: mainFile};
+    //   }
+    // }
+    // addModuleImportToStandaloneBootstrap(
+    //   host,
+    //   mainFile,
+    //   themingModuleWithDefaultTheme,
+    //   '@ui5/theming-ngx'
+    // );
+    // const oldContent = host.readText(mainFile);
+    // const newContent = oldContent.replace(themingModuleWithDefaultTheme, 'Ui5ThemingModule'); // This is fixing the incorrect import
+    // host.overwrite(mainFile, newContent);
+    return { changes: [], file: mainFile };
+}

package/schematics/add-theming/index.d.ts

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

package/schematics/add-theming/index.js

@@ -0,0 +1,29 @@
+"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 });
+exports.addTheming = addTheming;
+const workspace_1 = require("@schematics/angular/utility/workspace");
+const change_1 = require("@schematics/angular/utility/change");
+const add_theming_module_1 = require("./add-theming-module");
+const get_project_definition_1 = require("../utils/get-project-definition");
+function addTheming(options) {
+    return (tree, context) => (0, workspace_1.updateWorkspace)((workspace) => __awaiter(this, void 0, void 0, function* () {
+        const projectDefinition = (0, get_project_definition_1.getProjectDefinition)(workspace, options.project);
+        const update = (0, add_theming_module_1.addThemingModule)(tree, projectDefinition, context, options);
+        const exportRecorder = tree.beginUpdate(update.file);
+        for (const change of update.changes) {
+            if (change instanceof change_1.InsertChange) {
+                exportRecorder.insertLeft(change.pos, change.toAdd);
+            }
+        }
+        tree.commitUpdate(exportRecorder);
+    }));
+}

package/schematics/config.d.ts

@@ -0,0 +1,8 @@
+export declare const AvailableThemes: {
+    value: string;
+    name: string;
+}[];
+export declare const CommonCssParts: {
+    value: string;
+    name: string;
+}[];

package/schematics/config.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonCssParts = exports.AvailableThemes = void 0;
+exports.AvailableThemes = [
+    {
+        value: 'sap_horizon',
+        name: 'Morning Horizon (Light)'
+    },
+    {
+        value: 'sap_horizon_dark',
+        name: 'Evening Horizon (Dark)'
+    },
+    {
+        value: 'sap_horizon_hcb',
+        name: 'Horizon High Contrast Black'
+    },
+    {
+        value: 'sap_horizon_hcw',
+        name: 'Horizon High Contrast White'
+    },
+    {
+        value: 'sap_fiori_3',
+        name: 'Quartz Light'
+    },
+    {
+        value: 'sap_fiori_3_dark',
+        name: 'Quartz Dark'
+    },
+    {
+        value: 'sap_fiori_3_hcb',
+        name: 'Quartz High Contrast Black'
+    },
+    {
+        value: 'sap_fiori_3_hcw',
+        name: 'Quartz High Contrast White'
+    }
+];
+exports.CommonCssParts = [
+    {
+        value: 'sap-normalize',
+        name: 'Normalize CSS rules',
+    },
+    {
+        value: 'sap-padding',
+        name: 'Padding presets',
+    },
+    {
+        value: 'sap-typography',
+        name: 'General Typography styles',
+    },
+    {
+        value: 'sap-elevation',
+        name: 'Varioious elevation presets',
+    },
+    {
+        value: 'sap-shadow',
+        name: 'Varioous shadow presets',
+    },
+    {
+        value: 'sap-display',
+        name: 'Various display presets',
+    },
+    {
+        value: 'sap-margin',
+        name: 'Various margin presets',
+    },
+    {
+        value: 'sap-flex',
+        name: 'Useful flex-related presets',
+    },
+    {
+        value: 'sap-colors',
+        name: 'Various color presets',
+    },
+    {
+        value: 'sap-border-radius',
+        name: 'Various border radius presets',
+    },
+];

package/schematics/get-config.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "./schema";
+export declare function collectConfig(): Promise<Partial<Schema>>;

package/schematics/get-config.js

@@ -0,0 +1,46 @@
+"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 });
+exports.collectConfig = collectConfig;
+const config_1 = require("./config");
+const promt_1 = require("./utils/promt");
+function collectConfig() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const schema = {
+            commonCss: [],
+            theming: true,
+            defaultTheme: 'sap_horizon'
+        };
+        const includeCommonCss = yield askCommonCssDependency();
+        if (includeCommonCss) {
+            schema.commonCss = yield askCommonCssParts();
+        }
+        return schema;
+    });
+}
+function askCommonCssDependency() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, promt_1.askQuestion)({
+            type: 'confirm',
+            message: 'Would you like to add Common CSS into your application?',
+            default: false,
+        });
+    });
+}
+function askCommonCssParts() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, promt_1.askQuestion)({
+            type: 'checkbox',
+            message: 'Please select desired Common CSS features',
+            choices: config_1.CommonCssParts,
+        });
+    });
+}

package/schematics/get-i18n-config.d.ts

@@ -0,0 +1,4 @@
+export declare function getI18nConfig(): Promise<{
+    useI18n: boolean;
+    defaultLanguage: string | undefined;
+}>;

package/schematics/get-i18n-config.js

@@ -0,0 +1,31 @@
+"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 });
+exports.getI18nConfig = getI18nConfig;
+const promt_1 = require("./utils/promt");
+function getI18nConfig() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const useI18n = yield (0, promt_1.askQuestion)({
+            type: 'confirm',
+            message: 'Would you like to add i18n capabilities into your application?',
+            default: false,
+        });
+        const defaultLanguage = (useI18n ? yield (0, promt_1.askQuestion)({
+            type: 'input',
+            message: 'What is the default language of your application?',
+            default: 'en',
+        }) : undefined);
+        return {
+            useI18n,
+            defaultLanguage
+        };
+    });
+}

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

@@ -0,0 +1,4 @@
+import { Rule } from '@angular-devkit/schematics';
+import { NgAddSchema } from './schema';
+export declare function ngAdd(options: NgAddSchema): Rule;
+export declare function proceedWithSchematics(options: NgAddSchema): Rule;

package/schematics/ng-add/index.js

@@ -0,0 +1,36 @@
+"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 });
+exports.ngAdd = ngAdd;
+exports.proceedWithSchematics = proceedWithSchematics;
+const schematics_1 = require("@angular-devkit/schematics");
+const tasks_1 = require("@angular-devkit/schematics/tasks");
+const get_config_1 = require("../get-config");
+const get_i18n_config_1 = require("../get-i18n-config");
+function ngAdd(options) {
+    return (_, context) => __awaiter(this, void 0, void 0, function* () {
+        const userConfig = yield (0, get_config_1.collectConfig)();
+        const i18nConfig = yield (0, get_i18n_config_1.getI18nConfig)();
+        options = Object.assign(Object.assign(Object.assign({}, options), userConfig), i18nConfig);
+        // First, queue dependency installation task.
+        const dependenciesTaskId = context.addTask(new tasks_1.RunSchematicTask('add-dependencies', options));
+        // Wait for dependencies to be installed and proceed with main schematics.
+        context.addTask(new tasks_1.RunSchematicTask('proceed-with-schematics', options), [dependenciesTaskId]);
+        return (0, schematics_1.chain)([]);
+    });
+}
+function proceedWithSchematics(options) {
+    return (0, schematics_1.chain)([
+        (0, schematics_1.schematic)('add-styles', options),
+        (0, schematics_1.schematic)('add-theming', options),
+        (0, schematics_1.schematic)('add-i18n', options),
+    ]);
+}

package/schematics/ng-add/schema.d.ts

@@ -0,0 +1,5 @@
+import { Schema } from '../schema';
+export interface NgAddSchema extends Schema {
+    useI18n: boolean;
+    defaultLanguage?: string;
+}

package/schematics/ng-add/schema.js

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

package/schematics/ng-update/0.2.0-rc.0/index.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from '@angular-devkit/schematics';
+export default function (): Rule;