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

package/schematics/add-theming/index.ts

@@ -1,25 +0,0 @@
-import { updateWorkspace } from '@schematics/angular/utility/workspace';
-import { Change, InsertChange } from '@schematics/angular/utility/change';
-import { Rule } from '@angular-devkit/schematics';
-import { Schema } from '../schema';
-import { addThemingModule } from './add-theming-module';
-import { getProjectDefinition } from "../utils/get-project-definition";
-
-export function addTheming(options: Schema): Rule {
-  return (tree, context) =>
-    updateWorkspace(async (workspace) => {
-      const projectDefinition = getProjectDefinition(workspace, options.project);
-
-      const update: { changes: Change[], file: string } = addThemingModule(tree, projectDefinition, context, options);
-      const exportRecorder = tree.beginUpdate(update.file);
-
-      for (const change of update.changes) {
-        if (change instanceof InsertChange) {
-          exportRecorder.insertLeft(change.pos, change.toAdd);
-        }
-      }
-
-      tree.commitUpdate(exportRecorder);
-    });
-}
-

package/schematics/config.ts

@@ -1,77 +0,0 @@
-export const 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'
-  }
-];
-
-export const 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.ts

@@ -1,35 +0,0 @@
-import { CommonCssParts } from "./config";
-import { Schema } from "./schema";
-import { askQuestion } from './utils/promt';
-
-export async function collectConfig(): Promise<Partial<Schema>> {
-  const schema: Partial<Schema> = {
-    commonCss: [],
-    theming: true,
-    defaultTheme: 'sap_horizon'
-  };
-
-  const includeCommonCss = await askCommonCssDependency();
-
-  if (includeCommonCss) {
-    schema.commonCss = await askCommonCssParts();
-  }
-
-  return schema;
-}
-
-async function askCommonCssDependency(): Promise<boolean> {
-  return await askQuestion({
-    type: 'confirm',
-    message: 'Would you like to add Common CSS into your application?',
-    default: false,
-  });
-}
-
-async function askCommonCssParts(): Promise<string[]> {
-  return await askQuestion({
-    type: 'checkbox',
-    message: 'Please select desired Common CSS features',
-    choices: CommonCssParts,
-  });
-}

package/schematics/get-i18n-config.ts

@@ -1,20 +0,0 @@
-import { askQuestion } from './utils/promt';
-
-export async function getI18nConfig() {
-  const useI18n = await askQuestion({
-    type: 'confirm',
-    message:
-      'Would you like to add i18n capabilities into your application?',
-    default: false,
-  }) as unknown as boolean;
-  const defaultLanguage = (useI18n ? await askQuestion({
-    type: 'input',
-    message:
-      'What is the default language of your application?',
-    default: 'en',
-  }) as string : undefined);
-  return {
-    useI18n,
-    defaultLanguage
-  };
-}

package/schematics/ng-add/index.ts

@@ -1,35 +0,0 @@
-import {
-  Rule,
-  SchematicContext,
-  Tree,
-  chain,
-  schematic
-} from '@angular-devkit/schematics';
-import { RunSchematicTask } from '@angular-devkit/schematics/tasks';
-import { collectConfig } from '../get-config';
-import { getI18nConfig } from '../get-i18n-config'
-import { NgAddSchema } from './schema';
-
-export function ngAdd(options: NgAddSchema): Rule {
-  return async (_: Tree, context: SchematicContext) => {
-    const userConfig = await collectConfig();
-    const i18nConfig = await getI18nConfig();
-    options = {...options, ...userConfig, ...i18nConfig};
-
-    // First, queue dependency installation task.
-    const dependenciesTaskId = context.addTask(new RunSchematicTask('add-dependencies', options));
-
-    // Wait for dependencies to be installed and proceed with main schematics.
-    context.addTask(new RunSchematicTask('proceed-with-schematics', options), [dependenciesTaskId]);
-
-    return chain([]);
-  };
-}
-
-export function proceedWithSchematics(options: NgAddSchema): Rule {
-  return chain([
-    schematic('add-styles', options),
-    schematic('add-theming', options),
-    schematic('add-i18n', options),
-  ]);
-}

package/schematics/ng-add/schema.ts

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

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

@@ -1,27 +0,0 @@
-import { Rule, SchematicContext, Tree } from '@angular-devkit/schematics';
-import libraryPackageJson from '../../../package.json';
-import { NodePackageInstallTask } from "@angular-devkit/schematics/tasks";
-import { updateWorkspace } from "@schematics/angular/utility/workspace";
-import semver from "semver";
-
-export default function (): Rule {
-  return (tree: Tree, context: SchematicContext) => updateWorkspace(async () => {
-    const packageJsonContent = tree.read('package.json');
-    if (!packageJsonContent) {
-      throw new Error('Could not find package.json');
-    }
-    const packageJson = JSON.parse(packageJsonContent.toString('utf8'));
-    const ui5Dependencies = Object.keys(libraryPackageJson.peerDependencies as Record<string, string>)
-      .filter(packageName => packageName.startsWith('@ui5/'))
-      .map((peerDependency: string): [string, string] => ([peerDependency, libraryPackageJson.peerDependencies[peerDependency]]));
-    for (const [peerDependency, version] of ui5Dependencies) {
-      const existingDependency = packageJson.dependencies[peerDependency];
-      if (!existingDependency || !semver.satisfies(existingDependency, version)) {
-        packageJson.dependencies[peerDependency] = version;
-      }
-    }
-    tree.overwrite('package.json', JSON.stringify(packageJson, null, 2));
-    context.logger.info('✅️ Updated @ui5/* dependencies in package.json');
-    context.addTask(new NodePackageInstallTask());
-  });
-}

package/schematics/schema.ts

@@ -1,6 +0,0 @@
-export interface Schema {
-  project: string;
-  theming: boolean;
-  defaultTheme: string;
-  commonCss: string[];
-}

package/schematics/types.d.ts

@@ -1 +0,0 @@
-declare module 'inquirer';

package/schematics/utils/find-import-local-name.ts

@@ -1,43 +0,0 @@
-import * as ts from "typescript";
-
-/**
- * Finds the local name of an imported symbol. Could be the symbol name itself or its alias.
- * @param sourceFile File within which to search for the import.
- * @param name Actual name of the import, not its local alias.
- * @param moduleName Name of the module from which the symbol is imported.
- */
-export function findImportLocalName(
-  sourceFile: ts.SourceFile,
-  name: string,
-  moduleName: string,
-): string | null {
-  for (const node of sourceFile.statements) {
-    // Only look for top-level imports.
-    if (
-      !ts.isImportDeclaration(node) ||
-      !ts.isStringLiteral(node.moduleSpecifier) ||
-      node.moduleSpecifier.text !== moduleName
-    ) {
-      continue;
-    }
-
-    // Filter out imports that don't have the right shape.
-    if (
-      !node.importClause ||
-      !node.importClause.namedBindings ||
-      !ts.isNamedImports(node.importClause.namedBindings)
-    ) {
-      continue;
-    }
-
-    // Look through the elements of the declaration for the specific import.
-    for (const element of node.importClause.namedBindings.elements) {
-      if ((element.propertyName || element.name).text === name) {
-        // The local name is always in `name`.
-        return element.name.text;
-      }
-    }
-  }
-
-  return null;
-}

package/schematics/utils/find-import-providers-from-call.ts

@@ -1,28 +0,0 @@
-import * as ts from "typescript";
-import {findProvidersLiteral} from "./find-providers-literal";
-import {findImportLocalName} from "./find-import-local-name";
-
-/** Find a call to `importProvidersFrom` within a `bootstrapApplication` call. */
-export function findImportProvidersFromCall(bootstrapCall: ts.CallExpression): ts.CallExpression | null {
-  const providersLiteral = findProvidersLiteral(bootstrapCall);
-  const importProvidersName = findImportLocalName(
-    bootstrapCall.getSourceFile(),
-    'importProvidersFrom',
-    '@angular/core',
-  );
-
-  if (providersLiteral && importProvidersName) {
-    for (const element of providersLiteral.elements) {
-      // Look for an array element that calls the `importProvidersFrom` function.
-      if (
-        ts.isCallExpression(element) &&
-        ts.isIdentifier(element.expression) &&
-        element.expression.text === importProvidersName
-      ) {
-        return element;
-      }
-    }
-  }
-
-  return null;
-}

package/schematics/utils/find-ng-module-metadata.ts

@@ -1,28 +0,0 @@
-import ts from "typescript";
-import {isNgModuleCallExpression} from "./is-ng-module-expression";
-
-/**
- * Finds a NgModule declaration within the specified TypeScript node and returns the
- * corresponding metadata for it. This function searches breadth first because
- * NgModule's are usually not nested within other expressions or declarations.
- */
-export function findNgModuleMetadata(rootNode: ts.Node): ts.ObjectLiteralExpression | null {
-  // Add immediate child nodes of the root node to the queue.
-  const nodeQueue: ts.Node[] = [...rootNode.getChildren()];
-
-  while (nodeQueue.length) {
-    const node = nodeQueue.shift()!;
-
-    if (
-      ts.isDecorator(node) &&
-      ts.isCallExpression(node.expression) &&
-      isNgModuleCallExpression(node.expression)
-    ) {
-      return node.expression.arguments[0] as ts.ObjectLiteralExpression;
-    } else {
-      nodeQueue.push(...node.getChildren());
-    }
-  }
-
-  return null;
-}

package/schematics/utils/find-providers-literal.ts

@@ -1,24 +0,0 @@
-import * as ts from "typescript";
-
-/** Finds the `providers` array literal within a `bootstrapApplication` call. */
-export function findProvidersLiteral(bootstrapCall: ts.CallExpression): ts.ArrayLiteralExpression | null {
-  // The imports have to be in the second argument of
-  // the function which has to be an object literal.
-  if (
-    bootstrapCall.arguments.length > 1 &&
-    ts.isObjectLiteralExpression(bootstrapCall.arguments[1])
-  ) {
-    for (const prop of bootstrapCall.arguments[1].properties) {
-      if (
-        ts.isPropertyAssignment(prop) &&
-        ts.isIdentifier(prop.name) &&
-        prop.name.text === 'providers' &&
-        ts.isArrayLiteralExpression(prop.initializer)
-      ) {
-        return prop.initializer;
-      }
-    }
-  }
-
-  return null;
-}

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

@@ -1,11 +0,0 @@
-import { ProjectDefinition, WorkspaceDefinition } from "@schematics/angular/utility";
-import { SchematicsException } from "@angular-devkit/schematics";
-
-export function getProjectDefinition(workspace: WorkspaceDefinition, projectName: string): ProjectDefinition {
-  const projectDefinition = workspace.projects.get(projectName);
-
-  if (!projectDefinition) {
-    throw new SchematicsException('Project with such name not found.');
-  }
-  return projectDefinition;
-}

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

@@ -1,10 +0,0 @@
-import { ProjectDefinition, TargetDefinition } from "@schematics/angular/utility";
-import { SchematicsException } from "@angular-devkit/schematics";
-
-export function getProjectTarget(projectDefinition: ProjectDefinition, targetName: string, projectName?: string): TargetDefinition {
-  const target = projectDefinition.targets.get(targetName)
-  if (!target) {
-    throw new SchematicsException(`Target ${targetName} not found in project ${projectName || ''}`);
-  }
-  return target;
-}

package/schematics/utils/getModuleDeclaration.ts

@@ -1,25 +0,0 @@
-import * as ts from "typescript";
-import {getDecoratorMetadata, getMetadataField} from "@schematics/angular/utility/ast-utils";
-
-/**
- * Returns the RouterModule declaration from NgModule metadata, if any.
- */
-export function getModuleDeclaration(source: ts.SourceFile, module: string): ts.Expression | undefined {
-  const result = getDecoratorMetadata(source, 'NgModule', '@angular/core');
-  const node = result[0];
-  if (!node || !ts.isObjectLiteralExpression(node)) {
-    return undefined;
-  }
-  const matchingProperties = getMetadataField(node, 'imports');
-  if (!matchingProperties) {
-    return;
-  }
-  const assignment = matchingProperties[0] as any;
-  if (assignment.initializer.kind !== ts.SyntaxKind.ArrayLiteralExpression) {
-    return;
-  }
-  const arrLiteral = assignment.initializer;
-  return arrLiteral.elements
-    .filter((el: any) => el.kind === ts.SyntaxKind.CallExpression)
-    .find((el: any) => el.getText().startsWith(module));
-}

package/schematics/utils/getSourceFile.ts

@@ -1,14 +0,0 @@
-// Gets the ts source file from a path
-import {SchematicsException, Tree} from "@angular-devkit/schematics";
-import * as ts from "typescript";
-
-export function getSourceFile(host: Tree, path: string): ts.SourceFile {
-  const buffer = host.read(path);
-  if (!buffer) {
-    throw new SchematicsException(`Could not find file for path: ${path}`);
-  }
-
-  const text = buffer.toString('utf-8');
-
-  return ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true);
-}

package/schematics/utils/has-module-import.ts

@@ -1,39 +0,0 @@
-import {SchematicsException, Tree} from "@angular-devkit/schematics";
-import * as ts from "typescript";
-import {findNgModuleMetadata} from "./find-ng-module-metadata";
-
-export function hasNgModuleImport(tree: Tree, modulePath: string, className: string): boolean {
-  const moduleFileContent = tree.read(modulePath);
-
-  if (!moduleFileContent) {
-    throw new SchematicsException(`Could not read Angular module file: ${modulePath}`);
-  }
-
-  const parsedFile = ts.createSourceFile(
-    modulePath,
-    moduleFileContent.toString(),
-    ts.ScriptTarget.Latest,
-    true,
-  );
-  const ngModuleMetadata = findNgModuleMetadata(parsedFile);
-
-  if (!ngModuleMetadata) {
-    throw new SchematicsException(`Could not find NgModule declaration inside: "${modulePath}"`);
-  }
-
-  for (const property of ngModuleMetadata!.properties) {
-    if (
-      !ts.isPropertyAssignment(property) ||
-      property.name.getText() !== 'imports' ||
-      !ts.isArrayLiteralExpression(property.initializer)
-    ) {
-      continue;
-    }
-
-    if (property.initializer.elements.some(element => element.getText() === className)) {
-      return true;
-    }
-  }
-
-  return false;
-}

package/schematics/utils/is-ng-module-expression.ts

@@ -1,16 +0,0 @@
-import * as ts from "typescript";
-import {resolveIdentifierOfExpression} from "./resolve-identifier-of-expression";
-
-/** Whether the specified call expression is referring to a NgModule definition. */
-export function isNgModuleCallExpression(callExpression: ts.CallExpression): boolean {
-  if (
-    !callExpression.arguments.length ||
-    !ts.isObjectLiteralExpression(callExpression.arguments[0])
-  ) {
-    return false;
-  }
-
-  // The `NgModule` call expression name is never referring to a `PrivateIdentifier`.
-  const decoratorIdentifier = resolveIdentifierOfExpression(callExpression.expression);
-  return decoratorIdentifier ? decoratorIdentifier.text === 'NgModule' : false;
-}

package/schematics/utils/package-config.ts

@@ -1,55 +0,0 @@
-import {Tree} from '@angular-devkit/schematics';
-
-interface PackageJson {
-  dependencies: Record<string, string>;
-  devDependencies: Record<string, string>;
-}
-
-/**
- * Sorts the keys of the given object.
- * @returns A new object instance with sorted keys
- */
-function sortObjectByKeys(obj: Record<string, string>) {
-  return Object.keys(obj)
-    .sort()
-    .reduce((result, key) => {
-      result[key] = obj[key];
-      return result;
-    }, {} as Record<string, string>);
-}
-
-/** Adds a package to the package.json in the given host tree. */
-export function addPackageToPackageJson(host: Tree, pkg: string, version: string): Tree {
-  if (host.exists('package.json')) {
-    const sourceText = host.read('package.json')!.toString('utf-8');
-    const json = JSON.parse(sourceText) as PackageJson;
-
-    if (!json.dependencies) {
-      json.dependencies = {};
-    }
-
-    if (!json.dependencies[pkg]) {
-      json.dependencies[pkg] = version;
-      json.dependencies = sortObjectByKeys(json.dependencies);
-    }
-
-    host.overwrite('package.json', JSON.stringify(json, null, 2));
-  }
-
-  return host;
-}
-
-/** Gets the version of the specified package by looking at the package.json in the given tree. */
-export function getPackageVersionFromPackageJson(tree: Tree, name: string): string | null {
-  if (!tree.exists('package.json')) {
-    return null;
-  }
-
-  const packageJson = JSON.parse(tree.read('package.json')!.toString('utf8')) as PackageJson;
-
-  if (packageJson.dependencies && packageJson.dependencies[name]) {
-    return packageJson.dependencies[name];
-  }
-
-  return null;
-}

package/schematics/utils/project-main-file.ts

@@ -1,41 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {JsonValue, Path} from '@angular-devkit/core';
-import {ProjectDefinition} from '@angular-devkit/core/src/workspace';
-import {SchematicsException} from '@angular-devkit/schematics';
-
-/** Resolves the architect options for the build target of the given project. */
-export function getProjectTargetOptions(
-  project: ProjectDefinition,
-  buildTarget: string,
-): Record<string, JsonValue | undefined> {
-  const options = project.targets?.get(buildTarget)?.options;
-
-  if (!options) {
-    throw new SchematicsException(
-      `Cannot determine project target configuration for: ${buildTarget}.`,
-    );
-  }
-
-  return options;
-}
-
-/** Looks for the main TypeScript file in the given project and returns its path. */
-export function getProjectMainFile(project: ProjectDefinition): Path {
-  const buildOptions = getProjectTargetOptions(project, 'build');
-
-  if (!buildOptions['main']) {
-    throw new SchematicsException(
-      `Could not find the project main file inside of the ` +
-      `workspace config (${project.sourceRoot})`,
-    );
-  }
-
-  return buildOptions['main'] as Path;
-}

package/schematics/utils/promt.ts

@@ -1,6 +0,0 @@
-export async function askQuestion(config: any): Promise<any> {
-  const { prompt } = await import('inquirer');
-  config.name = 'question';
-  const result = await prompt([config]);
-  return result.question;
-}

package/schematics/utils/resolve-identifier-of-expression.ts

@@ -1,14 +0,0 @@
-import * as ts from "typescript";
-
-/**
- * Resolves the last identifier that is part of the given expression. This helps resolving
- * identifiers of nested property access expressions (e.g. myNamespace.core.NgModule).
- */
-export function resolveIdentifierOfExpression(expression: ts.Expression): ts.Identifier | null {
-  if (ts.isIdentifier(expression)) {
-    return expression;
-  } else if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.name)) {
-    return expression.name;
-  }
-  return null;
-}

package/theming/base-webcomponents-theming-provider.ts

@@ -1,49 +0,0 @@
-import {inject, Injectable, OnDestroy} from "@angular/core";
-import {Ui5ThemingProvider, Ui5ThemingService} from "@ui5/theming-ngx";
-import {BehaviorSubject, map, Observable, of, switchMap} from "rxjs";
-import supportedThemes from './supported-themes';
-import {setTheme} from '@ui5/webcomponents-base/dist/config/Theme.js';
-
-@Injectable()
-export abstract class WebcomponentsThemingProvider implements Ui5ThemingProvider, OnDestroy {
-  abstract name: string;
-
-  protected availableThemes$ = new BehaviorSubject<string[]>(supportedThemes);
-
-  protected _globalThemingService: Ui5ThemingService | null = inject(Ui5ThemingService, {optional: true});
-
-  /** @hidden */
-  protected constructor(
-    protected registerThemes: () => Promise<any>
-  ) {
-    registerThemes().then(() => {
-      this._globalThemingService?.registerProvider(this);
-    });
-  }
-
-  /** @hidden */
-  ngOnDestroy(): void {
-    this._globalThemingService?.unregisterProvider(this);
-  }
-
-  supportsTheme(theme: string): Observable<boolean> {
-    return this.getAvailableThemes().pipe(
-      map((themes) => themes.includes(theme))
-    );
-  }
-
-  getAvailableThemes(): Observable<string[]> {
-    return this.availableThemes$.asObservable();
-  }
-
-  setTheme(theme: string): Observable<boolean> {
-    return this.supportsTheme(theme).pipe(
-      switchMap((supported) => {
-        if (supported) {
-          setTheme(theme);
-        }
-        return of(supported);
-      })
-    );
-  }
-}

package/theming/index.ts

@@ -1,2 +0,0 @@
-export * from './theming.module';
-export * from './base-webcomponents-theming-provider';

package/theming/ng-package.json

@@ -1,5 +0,0 @@
-{
-  "lib": {
-    "entryFile": "index.ts"
-  }
-}