@ihk-gfi/lux-components-update 15.0.2 → 15.0.4

package/@angular-devkit/schematics-cli/schematic/files/README.md

@@ -0,0 +1,28 @@
+# Getting Started With Schematics
+
+This repository is a basic Schematic implementation that serves as a starting point to create and publish Schematics to NPM.
+
+### Testing
+
+To test locally, install `@angular-devkit/schematics-cli` globally and use the `schematics` command line tool. That tool acts the same as the `generate` command of the Angular CLI, but also has a debug mode.
+
+Check the documentation with
+
+```bash
+schematics --help
+```
+
+### Unit Testing
+
+`npm run test` will run the unit tests, using Jasmine as a runner and test framework.
+
+### Publishing
+
+To publish, simply do:
+
+```bash
+npm run build
+npm publish
+```
+
+That's it!

package/@angular-devkit/schematics-cli/schematic/files/__dot__gitignore

@@ -0,0 +1,18 @@
+# Outputs
+src/**/*.js
+src/**/*.js.map
+src/**/*.d.ts
+
+# IDEs
+.idea/
+jsconfig.json
+.vscode/
+
+# Misc
+node_modules/
+npm-debug.log*
+yarn-error.log*
+
+# Mac OSX Finder files.
+**/.DS_Store
+.DS_Store

package/@angular-devkit/schematics-cli/schematic/files/__dot__npmignore

@@ -0,0 +1,3 @@
+# Ignores TypeScript files, but keeps definitions.
+*.ts
+!*.d.ts

package/@angular-devkit/schematics-cli/schematic/files/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "<%= dasherize(name) %>",
+  "version": "0.0.0",
+  "description": "A schematics",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && jasmine src/**/*_spec.js"
+  },
+  "keywords": [
+    "schematics"
+  ],
+  "author": "<%= author %>",
+  "license": "MIT",
+  "schematics": "./src/collection.json",
+  "dependencies": {
+    "@angular-devkit/core": "^<%= coreVersion %>",
+    "@angular-devkit/schematics": "^<%= schematicsVersion %>",
+    "typescript": "~4.9.3"
+  },
+  "devDependencies": {
+    "@types/node": "^14.15.0",
+    "@types/jasmine": "~4.3.0",
+    "jasmine": "~4.5.0"
+  }
+}

package/@angular-devkit/schematics-cli/schematic/files/src/collection.json

@@ -0,0 +1,36 @@
+// By default, collection.json is a Loose-format JSON5 format, which means it's loaded using a
+// special loader and you can use comments, as well as single quotes or no-quotes for standard
+// JavaScript identifiers.
+// Note that this is only true for collection.json and it depends on the tooling itself.
+// We read package.json using a require() call, which is standard JSON.
+{
+  // This is just to indicate to your IDE that there is a schema for collection.json.
+  "$schema": "../node_modules/@angular-devkit/schematics/collection-schema.json",
+
+  // Schematics are listed as a map of schematicName => schematicDescription.
+  // Each description contains a description field which is required, a factory reference,
+  // an extends field and a schema reference.
+  // The extends field points to another schematic (either in the same collection or a
+  // separate collection using the format collectionName:schematicName).
+  // The factory is required, except when using the extends field. Then the factory can
+  // overwrite the extended schematic factory.
+  "schematics": {
+    "my-schematic": {
+      "description": "An example schematic",
+      "factory": "./my-schematic/index#mySchematic"
+    },
+    "my-other-schematic": {
+      "description": "A schematic that uses another schematics.",
+      "factory": "./my-other-schematic"
+    },
+    "my-full-schematic": {
+      "description": "A schematic using a source and a schema to validate options.",
+      "factory": "./my-full-schematic",
+      "schema": "./my-full-schematic/schema.json"
+    },
+    "my-extend-schematic": {
+      "description": "A schematic that extends another schematic.",
+      "extends": "my-full-schematic"
+    }
+  }
+}

package/@angular-devkit/schematics-cli/schematic/files/src/my-full-schematic/files/test2

@@ -0,0 +1,6 @@
+
+<% if (name) { %>
+  Hello <%= name %>, I'm a schematic.
+<% } else { %>
+  Why don't you give me your name with --name?
+<% } %>

package/@angular-devkit/schematics-cli/schematic/files/src/my-full-schematic/files/test__INDEX__

@@ -0,0 +1,2 @@
+
+This is test #<%= INDEX %>.

package/@angular-devkit/schematics-cli/schematic/files/src/my-full-schematic/index.ts

@@ -0,0 +1,53 @@
+import {
+  Rule,
+  SchematicContext,
+  Tree,
+  apply,
+  chain,
+  mergeWith,
+  schematic,
+  template,
+  url,
+} from '@angular-devkit/schematics';
+
+// Instead of `any`, it would make sense here to get a schema-to-dts package and output the
+// interfaces so you get type-safe options.
+export default function (options: any): Rule {
+  // The chain rule allows us to chain multiple rules and apply them one after the other.
+  return chain([
+    (_tree: Tree, context: SchematicContext) => {
+      // Show the options for this Schematics.
+      context.logger.info('My Full Schematic: ' + JSON.stringify(options));
+    },
+
+    // The schematic Rule calls the schematic from the same collection, with the options
+    // passed in. Please note that if the schematic has a schema, the options will be
+    // validated and could throw, e.g. if a required option is missing.
+    schematic('my-other-schematic', { option: true }),
+
+    // The mergeWith() rule merge two trees; one that's coming from a Source (a Tree with no
+    // base), and the one as input to the rule. You can think of it like rebasing a Source on
+    // top of your current set of changes. In this case, the Source is that apply function.
+    // The apply() source takes a Source, and apply rules to it. In our case, the Source is
+    // url(), which takes an URL and returns a Tree that contains all the files from that URL
+    // in it. In this case, we use the relative path `./files`, and so two files are going to
+    // be created (test1, and test2).
+    // We then apply the template() rule, which takes a tree and apply two templates to it:
+    //   path templates: this template replaces instances of __X__ in paths with the value of
+    //                   X from the options passed to template(). If the value of X is a
+    //                   function, the function will be called. If the X is undefined or it
+    //                   returns null (not empty string), the file or path will be removed.
+    //   content template: this is similar to EJS, but does so in place (there's no special
+    //                     extension), does not support additional functions if you don't pass
+    //                     them in, and only work on text files (we use an algorithm to detect
+    //                     if a file is binary or not).
+    mergeWith(
+      apply(url('./files'), [
+        template({
+          INDEX: options.index,
+          name: options.name,
+        }),
+      ]),
+    ),
+  ]);
+}

package/@angular-devkit/schematics-cli/schematic/files/src/my-full-schematic/index_spec.ts

@@ -0,0 +1,24 @@
+import { Tree } from '@angular-devkit/schematics';
+import { SchematicTestRunner } from '@angular-devkit/schematics/testing';
+import * as path from 'path';
+
+// SchematicTestRunner needs an absolute path to the collection to test.
+const collectionPath = path.join(__dirname, '../collection.json');
+
+describe('my-full-schematic', () => {
+  it('requires required option', async () => {
+    // We test that
+    const runner = new SchematicTestRunner('schematics', collectionPath);
+    await expectAsync(
+      runner.runSchematic('my-full-schematic', {}, Tree.empty())
+    ).toBeRejected();
+  });
+
+  it('works', async () => {
+    const runner = new SchematicTestRunner('schematics', collectionPath);
+    const tree = await runner.runSchematic('my-full-schematic', { name: 'str' }, Tree.empty());
+
+    // Listing files
+    expect(tree.files.sort()).toEqual(['/allo', '/hola', '/test1', '/test2']);
+  });
+});

package/@angular-devkit/schematics-cli/schematic/files/src/my-full-schematic/schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "MyFullSchematicsSchema",
+  "title": "My Full Schematics Schema",
+  "type": "object",
+  "properties": {
+    "index": {
+      "type": "number",
+      "default": 1
+    },
+    "name": {
+      "type": "string"
+    }
+  },
+  "required": ["name"]
+}

package/@angular-devkit/schematics-cli/schematic/files/src/my-other-schematic/index.ts

@@ -0,0 +1,27 @@
+import { Rule, SchematicContext, Tree, chain, schematic } from '@angular-devkit/schematics';
+
+// A factory is a RuleFactory. It takes the options that might have been coming from the command
+// line or another schematic. These can be defined in a schema.json, which will validate
+export default function (options: any): Rule {
+  // The chain rule allows us to chain multiple rules and apply them one after the other.
+  return chain([
+    (tree: Tree, context: SchematicContext) => {
+      // Show the options for this Schematics.
+      context.logger.info('My Other Schematic: ' + JSON.stringify(options));
+
+      // Create a single file. Since this tree is not branched, we are working in the
+      // same staging area as the other schematic, and as such cannot create the same
+      // file twice.
+      tree.create('hola', 'mundo');
+    },
+    // The schematic Rule calls the schematic from the same collection, with the options
+    // passed in. Please note that if the schematic has a schema, the options will be
+    // validated and could throw, e.g. if a required option is missing.
+    schematic('my-schematic', { option: true }),
+    (tree: Tree) => {
+      // But since we're working off the same staging area, we can move the file created
+      // by the schematic above.
+      tree.rename('hello', 'allo');
+    },
+  ]);
+}

package/@angular-devkit/schematics-cli/schematic/files/src/my-other-schematic/index_spec.ts

@@ -0,0 +1,14 @@
+import { Tree } from '@angular-devkit/schematics';
+import { SchematicTestRunner } from '@angular-devkit/schematics/testing';
+import * as path from 'path';
+
+const collectionPath = path.join(__dirname, '../collection.json');
+
+describe('my-other-schematic', () => {
+  it('works', async () => {
+    const runner = new SchematicTestRunner('schematics', collectionPath);
+    const tree = await runner.runSchematic('my-other-schematic', {}, Tree.empty());
+
+    expect(tree.files.sort()).toEqual(['/allo', '/hola']);
+  });
+});

package/@angular-devkit/schematics-cli/schematic/files/src/my-schematic/index.ts

@@ -0,0 +1,26 @@
+import { Rule, SchematicContext, Tree } from '@angular-devkit/schematics';
+
+// You don't have to export the function as default. You can also have more than one rule factory
+// per file.
+export function mySchematic(options: any): Rule {
+  return (tree: Tree, context: SchematicContext) => {
+    // Show the options for this Schematics.
+    // The logging here is at the discretion of the tooling. It can be ignored or only showing
+    // info/warnings/errors. If you use console.log() there is not guarantee it will be
+    // propagated to a user in any way (for example, an IDE running this schematic might
+    // have a logging window but no support for console.log).
+    context.logger.info('My Schematic: ' + JSON.stringify(options));
+
+    // Create a single file. This is the simplest example of transforming the tree.
+    // If a file with that name already exists, the generation will NOT fail until the tool
+    // is trying to commit this to disk. This is because we allow you to work on what is
+    // called a "staging" area, and only finalize those changes when the schematics is
+    // done. This allows you to create files without having to verify if they exist
+    // already, then rename them later. Templating works in a similar fashion.
+    tree.create('hello', 'world');
+
+    // At the end, you can either return a Tree (that will be used), or an observable of a
+    // Tree (if you have some asynchronous tasks).
+    return tree;
+  };
+}

package/@angular-devkit/schematics-cli/schematic/files/src/my-schematic/index_spec.ts

@@ -0,0 +1,14 @@
+import { Tree } from '@angular-devkit/schematics';
+import { SchematicTestRunner } from '@angular-devkit/schematics/testing';
+import * as path from 'path';
+
+const collectionPath = path.join(__dirname, '../collection.json');
+
+describe('my-schematic', () => {
+  it('works', async () => {
+    const runner = new SchematicTestRunner('schematics', collectionPath);
+    const tree = await runner.runSchematic('my-schematic', {}, Tree.empty());
+
+    expect(tree.files).toEqual(['/hello']);
+  });
+});

package/@angular-devkit/schematics-cli/schematic/files/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "baseUrl": "tsconfig",
+    "lib": ["es2018", "dom"],
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "noEmitOnError": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "noUnusedParameters": true,
+    "noUnusedLocals": true,
+    "rootDir": "src/",
+    "skipDefaultLibCheck": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strictNullChecks": true,
+    "target": "es6",
+    "types": ["jasmine", "node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["src/*/files/**/*"]
+}

package/@schematics/angular/application/files/src/index.html.template

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title><%= utils.classify(name) %></title>
+  <base href="/">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <link rel="icon" type="image/x-icon" href="favicon.ico">
+</head>
+<body>
+  <<%= prefix %>-root></<%= prefix %>-root>
+</body>
+</html>

package/@schematics/angular/application/files/src/main.ts.template

@@ -0,0 +1,13 @@
+<% if(!!viewEncapsulation) { %>import { ViewEncapsulation } from '@angular/core';
+<% }%>import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+
+import { AppModule } from './app/app.module';
+
+<% if(!!viewEncapsulation) { %>
+platformBrowserDynamic().bootstrapModule(AppModule, {
+  defaultEncapsulation: ViewEncapsulation.<%= viewEncapsulation %>
+})
+  .catch(err => console.error(err));<% } else { %>
+platformBrowserDynamic().bootstrapModule(AppModule)
+  .catch(err => console.error(err));
+<% } %>

package/@schematics/angular/application/files/src/styles.__style__.template

@@ -0,0 +1 @@
+/* You can add global styles to this file, and also import other style files */

package/@schematics/angular/application/files/tsconfig.app.json.template

@@ -0,0 +1,14 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "<%= relativePathToWorkspaceRoot %>/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "<%= relativePathToWorkspaceRoot %>/out-tsc/app",
+    "types": []
+  },
+  "files": [
+    "src/main.ts"
+  ],
+  "include": [
+    "src/**/*.d.ts"
+  ]
+}

package/@schematics/angular/application/files/tsconfig.spec.json.template

@@ -0,0 +1,14 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "<%= relativePathToWorkspaceRoot %>/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "<%= relativePathToWorkspaceRoot %>/out-tsc/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "include": [
+    "src/**/*.spec.ts",
+    "src/**/*.d.ts"
+  ]
+}

package/@schematics/angular/class/files/__name@dasherize____type__.spec.ts.template

@@ -0,0 +1,7 @@
+import { <%= classify(name) %> } from './<%= dasherize(name) %><%= type %>';
+
+describe('<%= classify(name) %>', () => {
+  it('should create an instance', () => {
+    expect(new <%= classify(name) %>()).toBeTruthy();
+  });
+});

package/@schematics/angular/class/files/__name@dasherize____type__.ts.template

@@ -0,0 +1,2 @@
+export class <%= classify(name) %> {
+}

package/@schematics/angular/component/files/__name@dasherize@if-flat__/__name@dasherize__.__type@dasherize__.__style__.template

@@ -0,0 +1,6 @@
+<% if(displayBlock){ if(style != 'sass') { %>:host {
+  display: block;
+}
+<% } else { %>\:host
+  display: block;
+<% }} %>

package/@schematics/angular/component/files/__name@dasherize@if-flat__/__name@dasherize__.__type@dasherize__.html.template

@@ -0,0 +1 @@
+<p><%= dasherize(name) %> works!</p>

package/@schematics/angular/component/files/__name@dasherize@if-flat__/__name@dasherize__.__type@dasherize__.spec.ts.template

@@ -0,0 +1,23 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { <%= classify(name) %><%= classify(type) %> } from './<%= dasherize(name) %><%= type ? '.' + dasherize(type): '' %>';
+
+describe('<%= classify(name) %><%= classify(type) %>', () => {
+  let component: <%= classify(name) %><%= classify(type) %>;
+  let fixture: ComponentFixture<<%= classify(name) %><%= classify(type) %>>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      <%= standalone ? 'imports' : 'declarations' %>: [ <%= classify(name) %><%= classify(type) %> ]
+    })
+    .compileComponents();
+
+    fixture = TestBed.createComponent(<%= classify(name) %><%= classify(type) %>);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

package/@schematics/angular/component/files/__name@dasherize@if-flat__/__name@dasherize__.__type@dasherize__.ts.template

@@ -0,0 +1,27 @@
+import { <% if(changeDetection !== 'Default') { %>ChangeDetectionStrategy, <% }%>Component<% if(!!viewEncapsulation) { %>, ViewEncapsulation<% }%> } from '@angular/core';<% if(standalone) {%>
+import { CommonModule } from '@angular/common';<% } %>
+
+@Component({<% if(!skipSelector) {%>
+  selector: '<%= selector %>',<%}%><% if(standalone) {%>
+  standalone: true,
+  imports: [CommonModule],<%}%><% if(inlineTemplate) { %>
+  template: `
+    <p>
+      <%= dasherize(name) %> works!
+    </p>
+  `<% } else { %>
+  templateUrl: './<%= dasherize(name) %><%= type ? '.' + dasherize(type): '' %>.html'<% } if(inlineStyle) { %>,
+  styles: [<% if(displayBlock){ %>
+    `
+      :host {
+        display: block;
+      }
+    `<% } %>
+  ]<% } else if (style !== 'none') { %>,
+  styleUrls: ['./<%= dasherize(name) %><%= type ? '.' + dasherize(type): '' %>.<%= style %>']<% } %><% if(!!viewEncapsulation) { %>,
+  encapsulation: ViewEncapsulation.<%= viewEncapsulation %><% } if (changeDetection !== 'Default') { %>,
+  changeDetection: ChangeDetectionStrategy.<%= changeDetection %><% } %>
+})
+export class <%= classify(name) %><%= classify(type) %> {
+
+}

package/@schematics/angular/config/files/karma.conf.js.template

@@ -0,0 +1,39 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/1.0/config/configuration-file.html
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    frameworks: ['jasmine', '@angular-devkit/build-angular'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage'),
+      require('@angular-devkit/build-angular/plugins/karma')
+    ],
+    client: {
+      jasmine: {
+        // you can add configuration options for Jasmine here
+        // the possible options are listed at https://jasmine.github.io/api/edge/Configuration.html
+        // for example, you can disable the random execution with `random: false`
+        // or set a specific seed with `seed: 4321`
+      },
+      clearContext: false // leave Jasmine Spec Runner output visible in browser
+    },
+    jasmineHtmlReporter: {
+      suppressAll: true // removes the duplicated traces
+    },
+    coverageReporter: {
+      dir: require('path').join(__dirname, '<%= relativePathToWorkspaceRoot %>/coverage/<%= folderName %>'),
+      subdir: '.',
+      reporters: [
+        { type: 'html' },
+        { type: 'text-summary' }
+      ]
+    },
+    reporters: ['progress', 'kjhtml'],
+    browsers: ['Chrome'],
+    restartOnFileChange: true
+  });
+};

package/@schematics/angular/directive/files/__name@dasherize@if-flat__/__name@dasherize__.directive.spec.ts.template

@@ -0,0 +1,8 @@
+import { <%= classify(name) %>Directive } from './<%= dasherize(name) %>.directive';
+
+describe('<%= classify(name) %>Directive', () => {
+  it('should create an instance', () => {
+    const directive = new <%= classify(name) %>Directive();
+    expect(directive).toBeTruthy();
+  });
+});

package/@schematics/angular/directive/files/__name@dasherize@if-flat__/__name@dasherize__.directive.ts.template

@@ -0,0 +1,11 @@
+import { Directive } from '@angular/core';
+
+@Directive({
+  selector: '[<%= selector %>]'<% if(standalone) {%>,
+  standalone: true<%}%>
+})
+export class <%= classify(name) %>Directive {
+
+  constructor() { }
+
+}

package/@schematics/angular/e2e/files/protractor.conf.js.template

@@ -0,0 +1,37 @@
+// @ts-check
+// Protractor configuration file, see link for more information
+// https://github.com/angular/protractor/blob/master/lib/config.ts
+
+const { SpecReporter, StacktraceOption } = require('jasmine-spec-reporter');
+
+/**
+ * @type { import("protractor").Config }
+ */
+exports.config = {
+  allScriptsTimeout: 11000,
+  specs: [
+    './src/**/*.e2e-spec.ts'
+  ],
+  capabilities: {
+    browserName: 'chrome'
+  },
+  directConnect: true,
+  SELENIUM_PROMISE_MANAGER: false,
+  baseUrl: 'http://localhost:4200/',
+  framework: 'jasmine',
+  jasmineNodeOpts: {
+    showColors: true,
+    defaultTimeoutInterval: 30000,
+    print: function() {}
+  },
+  onPrepare() {
+    require('ts-node').register({
+      project: require('path').join(__dirname, './tsconfig.json')
+    });
+    jasmine.getEnv().addReporter(new SpecReporter({
+      spec: {
+        displayStacktrace: StacktraceOption.PRETTY
+      }
+    }));
+  }
+};

package/@schematics/angular/e2e/files/src/app.e2e-spec.ts.template

@@ -0,0 +1,23 @@
+import { browser, logging } from 'protractor';
+import { AppPage } from './app.po';
+
+describe('workspace-project App', () => {
+  let page: AppPage;
+
+  beforeEach(() => {
+    page = new AppPage();
+  });
+
+  it('should display welcome message', async () => {
+    await page.navigateTo();
+    expect(await page.getTitleText()).toEqual('<%= relatedAppName %> app is running!');
+  });
+
+  afterEach(async () => {
+    // Assert that there are no errors emitted from the browser
+    const logs = await browser.manage().logs().get(logging.Type.BROWSER);
+    expect(logs).not.toContain(jasmine.objectContaining({
+      level: logging.Level.SEVERE,
+    } as logging.Entry));
+  });
+});

package/@schematics/angular/e2e/files/src/app.po.ts.template

@@ -0,0 +1,11 @@
+import { browser, by, element } from 'protractor';
+
+export class AppPage {
+  async navigateTo(): Promise<unknown> {
+    return browser.get(browser.baseUrl);
+  }
+
+  async getTitleText(): Promise<string> {
+    return element(by.css('<%= rootSelector %> .content span')).getText();
+  }
+}

package/@schematics/angular/e2e/files/tsconfig.json.template

@@ -0,0 +1,13 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "<%= relativePathToWorkspaceRoot %>/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "<%= relativePathToWorkspaceRoot %>/out-tsc/e2e",
+    "module": "commonjs",
+    "target": "es2019",
+    "types": [
+      "jasmine",
+      "node"
+    ]
+  }
+}

package/@schematics/angular/enum/files/__name@dasherize____type__.ts.template

@@ -0,0 +1,2 @@
+export enum <%= classify(name) %> {
+}

package/@schematics/angular/interface/files/__name@dasherize____type__.ts.template

@@ -0,0 +1,2 @@
+export interface <%= prefix %><%= classify(name) %> {
+}