@eui/showcase 15.0.0-next.9 → 15.0.0-rc.2

package/esm2020/lib/components/playground/playground.component.mjs

@@ -0,0 +1,203 @@
+import { Component, ElementRef, Input, ViewChild } from '@angular/core';
+import sdk from '@stackblitz/sdk';
+import { lastValueFrom } from 'rxjs';
+import { angularJsonFile, indexHtmlFile, mainFile, PACKAGE_JSON, polyfillsFile, tsConfig } from './stackblitz.files';
+import * as i0 from "@angular/core";
+import * as i1 from "@eui/core";
+import * as i2 from "@angular/common/http";
+import * as i3 from "@eui/components/eui-block-content";
+export class PlaygroundComponent {
+    constructor(renderer, elementRef, appShell, http) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.appShell = appShell;
+        this.http = http;
+        this.title = 'eUI Playground';
+        this.activated = false;
+        this.isLoaded = false;
+    }
+    ngOnChanges(changes) {
+        if (changes.activated) {
+            if (changes.activated.currentValue) {
+                this.initStackblitz();
+            }
+            else {
+                this.isLoaded = false;
+            }
+        }
+    }
+    initStackblitz() {
+        this.getStackblitzDependencies()
+            .then((deps) => {
+            const { dependencies, devDependencies } = deps;
+            const { selector, className } = this.extractComponentMetadata(this.typescriptContent);
+            const moduleName = this.extractModuleName(this.typescriptContent);
+            return sdk.embedProject('stackblitz', {
+                title: this.title,
+                description: `An eUI example for the ${this.title}.`,
+                template: 'angular-cli',
+                files: {
+                    'src/component.html': this.htmlContent,
+                    'src/component.ts': this.appendVitalNgModules(this.typescriptContent),
+                    // 'src/app.module.ts': moduleFile(className, this.modules),
+                    'src/main.ts': mainFile(moduleName),
+                    'src/polyfills.ts': polyfillsFile,
+                    'src/index.html': indexHtmlFile(selector),
+                    'angular.json': angularJsonFile,
+                    'package.json': JSON.stringify({
+                        ...PACKAGE_JSON,
+                        dependencies,
+                        devDependencies,
+                    }, null, 2),
+                    'tsconfig.json': tsConfig
+                },
+                settings: {
+                    compile: {
+                        trigger: 'auto',
+                        clearConsole: false,
+                    },
+                },
+                dependencies,
+            }, {
+                openFile: ['component.ts'],
+                height: 500,
+            });
+        })
+            .then((instance) => {
+            this.stackblitzInstance = instance;
+            this.isLoaded = true;
+        });
+    }
+    /**
+     * Retrieve only the dependencies that stackblitz will need filtered from @eui/deps-base
+     *
+     * @private
+     */
+    getStackblitzDependencies() {
+        // a list of dependencies only stackblitz needs
+        const stackblitzDependencies = [
+            '@angular/animations',
+            '@angular/cdk',
+            '@angular/common',
+            '@angular/compiler',
+            '@angular/core',
+            '@angular/forms',
+            '@angular/material',
+            '@angular/material-moment-adapter',
+            '@angular/platform-browser',
+            '@angular/platform-browser-dynamic',
+            '@angular/router',
+            '@eui/base',
+            '@eui/components',
+            '@eui/core',
+            '@eui/styles',
+            '@eui/styles-base',
+            '@ngrx/effects',
+            '@ngrx/store',
+            '@ngx-translate/core',
+            'localforage',
+            'lodash-es',
+            'reselect',
+            'rxjs',
+            'tslib',
+            'zone.js'
+        ];
+        const stackblitzDevDependencies = [
+            '@angular-devkit/build-angular',
+            '@angular/cli',
+            '@angular/compiler-cli',
+            'typescript'
+        ];
+        return this.getCurrentShowcaseEuiVersion()
+            .then((version) => this.retrievePackageDependencies(version))
+            .then((dependencies) => {
+            // filter dependencies to only what stackblitz needs
+            let filteredArr = Object.entries(dependencies)
+                .filter((v) => stackblitzDependencies.find(s => s === v[0]));
+            let filteredObj = Object.fromEntries(filteredArr);
+            let extraDependencies = {
+                uuid: '8.3.2',
+                'ngx-device-detector': '3.0.0',
+                'ngx-moment': '~6.0.0',
+                'ngx-mask': '^14.0.0',
+                'cleave.js': '^1.6.0',
+                moment: '^2.19.3',
+                extend: '^3.0.2',
+            };
+            // filter devDependencies to only what stackblitz needs
+            filteredArr = Object.entries(dependencies)
+                .filter((v) => stackblitzDevDependencies.find(s => s === v[0]));
+            dependencies = { ...extraDependencies, ...filteredObj };
+            let devDependencies = Object.fromEntries(filteredArr);
+            return { dependencies, devDependencies };
+        });
+    }
+    /**
+     * Retrieve the dependencies from the package.json file of @eui/deps-base for the given version.
+     *
+     * @param version
+     * @private
+     */
+    retrievePackageDependencies(version) {
+        return fetch(`https://unpkg.com/@eui/deps-base@${version}/package.json`)
+            .then((response) => response.json())
+            .then((pkg) => pkg?.dependencies);
+    }
+    /**
+     * Retrieve the eUI version used to build the showcase from application app-metadata.json
+     *
+     * @private
+     */
+    getCurrentShowcaseEuiVersion() {
+        return lastValueFrom(this.http.get('assets/app-metadata.json', { responseType: 'json' }))
+            .then((res) => res?.appVersion || 'latest');
+    }
+    /**
+     * extract the name of the component class name and selector name from the typescript content
+     *
+     * @param contents
+     * @private
+     */
+    extractComponentMetadata(contents) {
+        const className = contents.match(/export class ([\w\d]+)/);
+        const selectorName = contents.match(/selector: '([\w\d-]+)'/);
+        return { className: className ? className[1] : '', selector: selectorName ? selectorName[1] : '' };
+    }
+    /**
+     * extract module class name from the typescript content
+     *
+     * @param contents
+     * @private
+     */
+    extractModuleName(contents) {
+        const moduleClass = contents.match(/export class (\w+Module)/);
+        return moduleClass ? moduleClass[1] : '';
+    }
+    appendVitalNgModules(contents) {
+        const imports = contents.match(/imports: \[([\s\S]*?)\]/);
+        // appends BrowserModule to imports
+        contents = contents.replace(/imports: \[([\s\S]*?)\]/, `imports: [BrowserModule, $1]`);
+        // appends import of BrowserModule
+        return `import { BrowserModule } from '@angular/platform-browser';\n${contents}`;
+    }
+}
+/** @nocollapse */ PlaygroundComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0-next.4", ngImport: i0, type: PlaygroundComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i1.UxAppShellService }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ PlaygroundComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.0-next.4", type: PlaygroundComponent, selector: "eui-playground", inputs: { title: "title", htmlContent: "htmlContent", typescriptContent: "typescriptContent", activated: "activated", modules: "modules" }, viewQueries: [{ propertyName: "stackblitzElWrapper", first: true, predicate: ["container"], descendants: true, read: ElementRef, static: true }], usesOnChanges: true, ngImport: i0, template: "<eui-block-content [isBlocked]=\"!isLoaded\">\n    <iframe #container id=\"stackblitz\"></iframe>\n</eui-block-content>\n", dependencies: [{ kind: "component", type: i3.EuiBlockContentComponent, selector: "eui-block-content", inputs: ["isBlocked"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0-next.4", ngImport: i0, type: PlaygroundComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'eui-playground', template: "<eui-block-content [isBlocked]=\"!isLoaded\">\n    <iframe #container id=\"stackblitz\"></iframe>\n</eui-block-content>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i1.UxAppShellService }, { type: i2.HttpClient }]; }, propDecorators: { title: [{
+                type: Input
+            }], htmlContent: [{
+                type: Input
+            }], typescriptContent: [{
+                type: Input
+            }], activated: [{
+                type: Input
+            }], modules: [{
+                type: Input
+            }], stackblitzElWrapper: [{
+                type: ViewChild,
+                args: ['container', { read: ElementRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"playground.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/playground/playground.component.ts","../../../../../src/lib/components/playground/playground.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    ElementRef,\n    Input,\n    OnChanges,\n    Renderer2,\n    SimpleChanges,\n    ViewChild\n} from '@angular/core';\nimport { UxAppShellService } from '@eui/core';\nimport { HttpClient } from '@angular/common/http';\nimport sdk, { ProjectDependencies, VM } from '@stackblitz/sdk';\nimport { lastValueFrom } from 'rxjs';\nimport {\n    angularJsonFile,\n    indexHtmlFile,\n    mainFile,\n    moduleFile,\n    PACKAGE_JSON,\n    polyfillsFile,\n    tsConfig\n} from './stackblitz.files';\n\n@Component({\n    selector: 'eui-playground',\n    templateUrl: `playground.component.html`,\n})\nexport class PlaygroundComponent implements OnChanges {\n\n    @Input()\n    public title: string = 'eUI Playground';\n    @Input()\n    public htmlContent: string;\n    @Input()\n    public typescriptContent: string;\n    @Input()\n    public activated: boolean = false;\n    @Input()\n    public modules: [{name: string; path: string;}];\n    public isLoaded: boolean = false;\n    @ViewChild('container', {read: ElementRef, static: true})\n    private stackblitzElWrapper: ElementRef<HTMLIFrameElement>;\n    /** instance that holds the stackblitz VM object */\n    private stackblitzInstance: VM;\n\n    constructor(private renderer: Renderer2,\n                private elementRef: ElementRef,\n                private appShell: UxAppShellService,\n                private http: HttpClient) {\n    }\n\n    ngOnChanges(changes: SimpleChanges): void {\n        if (changes.activated) {\n            if(changes.activated.currentValue) {\n                this.initStackblitz();\n            } else {\n                this.isLoaded = false;\n            }\n        }\n    }\n\n    private initStackblitz(): void {\n        this.getStackblitzDependencies()\n            .then((deps) => {\n                const {dependencies, devDependencies} = deps;\n                const { selector, className } = this.extractComponentMetadata(this.typescriptContent);\n                const moduleName = this.extractModuleName(this.typescriptContent);\n                return sdk.embedProject(\n                    'stackblitz',\n                    {\n                        title: this.title,\n                        description: `An eUI example for the ${this.title}.`,\n                        template: 'angular-cli',\n                        files: {\n                            'src/component.html': this.htmlContent,\n                            'src/component.ts': this.appendVitalNgModules(this.typescriptContent),\n                            // 'src/app.module.ts': moduleFile(className, this.modules),\n                            'src/main.ts': mainFile(moduleName),\n                            'src/polyfills.ts': polyfillsFile,\n                            'src/index.html': indexHtmlFile(selector),\n                            'angular.json': angularJsonFile,\n                            'package.json': JSON.stringify({\n                                ...PACKAGE_JSON,\n                                dependencies,\n                                devDependencies,\n                            }, null, 2),\n                            'tsconfig.json': tsConfig\n                        },\n                        settings: {\n                            compile: {\n                                trigger: 'auto',\n                                clearConsole: false,\n                            },\n                        },\n                        dependencies,\n                    },\n                    {\n                        openFile: ['component.ts'],\n                        height: 500,\n                    },\n                );\n            })\n            .then((instance: VM) => {\n                this.stackblitzInstance = instance;\n                this.isLoaded = true;\n            });\n    }\n\n    /**\n     * Retrieve only the dependencies that stackblitz will need filtered from @eui/deps-base\n     *\n     * @private\n     */\n    private getStackblitzDependencies(): Promise<{ dependencies: ProjectDependencies; devDependencies: ProjectDependencies; }> {\n        // a list of dependencies only stackblitz needs\n        const stackblitzDependencies = [\n            '@angular/animations',\n            '@angular/cdk',\n            '@angular/common',\n            '@angular/compiler',\n            '@angular/core',\n            '@angular/forms',\n            '@angular/material',\n            '@angular/material-moment-adapter',\n            '@angular/platform-browser',\n            '@angular/platform-browser-dynamic',\n            '@angular/router',\n            '@eui/base',\n            '@eui/components',\n            '@eui/core',\n            '@eui/styles',\n            '@eui/styles-base',\n            '@ngrx/effects',\n            '@ngrx/store',\n            '@ngx-translate/core',\n            'localforage',\n            'lodash-es',\n            'reselect',\n            'rxjs',\n            'tslib',\n            'zone.js'\n        ];\n\n        const stackblitzDevDependencies = [\n            '@angular-devkit/build-angular',\n            '@angular/cli',\n            '@angular/compiler-cli',\n            'typescript'\n        ];\n\n        return this.getCurrentShowcaseEuiVersion()\n            .then((version) => this.retrievePackageDependencies(version))\n            .then((dependencies) => {\n                // filter dependencies to only what stackblitz needs\n                let filteredArr = Object.entries(dependencies)\n                    .filter((v) => stackblitzDependencies.find(s => s === v[0]));\n                let filteredObj = Object.fromEntries(filteredArr);\n                let extraDependencies = {\n                    uuid: '8.3.2',\n                    'ngx-device-detector': '3.0.0',\n                    'ngx-moment': '~6.0.0',\n                    'ngx-mask': '^14.0.0',\n                    'cleave.js': '^1.6.0',\n                    moment: '^2.19.3',\n                    extend: '^3.0.2',\n                };\n                // filter devDependencies to only what stackblitz needs\n                filteredArr = Object.entries(dependencies)\n                    .filter((v) => stackblitzDevDependencies.find(s => s === v[0]));\n                dependencies = {...extraDependencies, ...filteredObj};\n                let devDependencies = Object.fromEntries(filteredArr);\n\n                return {dependencies, devDependencies};\n            } );\n    }\n\n    /**\n     * Retrieve the dependencies from the package.json file of @eui/deps-base for the given version.\n     *\n     * @param version\n     * @private\n     */\n    private retrievePackageDependencies(version): Promise<ProjectDependencies> {\n        return fetch(`https://unpkg.com/@eui/deps-base@${version}/package.json`)\n            .then((response) => response.json())\n            .then((pkg) => pkg?.dependencies);\n    }\n\n    /**\n     * Retrieve the eUI version used to build the showcase from application app-metadata.json\n     *\n     * @private\n     */\n    private getCurrentShowcaseEuiVersion(): Promise<string> {\n        return lastValueFrom(this.http.get<any>('assets/app-metadata.json', {responseType: 'json'}))\n            .then((res) => res?.appVersion || 'latest');\n    }\n\n    /**\n     * extract the name of the component class name and selector name from the typescript content\n     *\n     * @param contents\n     * @private\n     */\n    private extractComponentMetadata(contents: string): { selector: string; className: string; } {\n        const className = contents.match(/export class ([\\w\\d]+)/);\n        const selectorName = contents.match(/selector: '([\\w\\d-]+)'/);\n        return { className: className ? className[1] : '', selector: selectorName ? selectorName[1] : ''};\n    }\n\n    /**\n     * extract module class name from the typescript content\n     *\n     * @param contents\n     * @private\n     */\n    private extractModuleName(contents: string): string {\n        const moduleClass = contents.match(/export class (\\w+Module)/);\n        return moduleClass ? moduleClass[1] : '';\n    }\n\n    private appendVitalNgModules(contents: string): string {\n        const imports = contents.match(/imports: \\[([\\s\\S]*?)\\]/);\n        // appends BrowserModule to imports\n        contents = contents.replace(/imports: \\[([\\s\\S]*?)\\]/, `imports: [BrowserModule, $1]`);\n        // appends import of BrowserModule\n        return `import { BrowserModule } from '@angular/platform-browser';\\n${contents}`;\n    }\n\n}\n","<eui-block-content [isBlocked]=\"!isLoaded\">\n    <iframe #container id=\"stackblitz\"></iframe>\n</eui-block-content>\n"]}

package/esm2020/lib/components/playground/stackblitz.files.mjs

@@ -0,0 +1,208 @@
+export const polyfillsFile = `import 'zone.js/dist/zone';`;
+export const mainFile = (moduleName) => `
+import './polyfills';
+import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+import { preInitApp } from '@eui/core';
+import { ${moduleName} } from './component';
+
+preInitApp({production: false}).then(() => platformBrowserDynamic().bootstrapModule(${moduleName}).then(ref => {
+      // Ensure Angular destroys itself on hot reloads.
+      if (window['ngRef']) {
+        window['ngRef'].destroy();
+      }
+      window['ngRef'] = ref;
+
+      // Otherwise, log the boot error
+    }).catch(err => console.error(err))
+);
+
+`;
+export const moduleFile = (componentName, m = []) => {
+    return `
+import { NgModule, InjectionToken } from '@angular/core';
+import { BrowserModule } from '@angular/platform-browser';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { RouterModule } from '@angular/router';
+import { APP_BASE_HREF } from '@angular/common';
+import { HttpClientModule } from '@angular/common/http';
+import { StoreModule } from '@ngrx/store';
+import { EffectsModule } from '@ngrx/effects';
+import { TranslateModule } from '@ngx-translate/core';
+import { FormsModule } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+import { EuiAllModule } from '@eui/components';
+import {
+    reducers as coreReducers,
+    CoreModule as EuiCoreModule,
+    translateConfig,
+    CoreModuleEffects,
+    EUI_CONFIG_TOKEN,
+} from '@eui/core';
+
+import { ${componentName} } from './component';
+` + m.map((i) => `import { ${i.name} } from '${i.path}';\n`).join('') + `
+
+export const REDUCER_TOKEN = new InjectionToken<any>('Registered Reducers');
+
+@NgModule({
+  imports: [
+    BrowserAnimationsModule,
+    CommonModule,
+    BrowserModule,
+    FormsModule,
+    EuiAllModule,
+    HttpClientModule,
+    RouterModule.forRoot([]),
+    EuiCoreModule.forRoot(),
+    EffectsModule.forRoot([...CoreModuleEffects]),
+    TranslateModule.forRoot(translateConfig),
+    StoreModule.forRoot(REDUCER_TOKEN, { })
+    ` + m.map((i) => `${i.name},`).join('') + `
+  ],
+  declarations: [${componentName}],
+  providers: [
+    {
+        provide: REDUCER_TOKEN,
+        deps: [],
+        useFactory: () => Object.assign({}, coreReducers),
+    },
+    {
+        provide: EUI_CONFIG_TOKEN,
+        useValue: { appConfig: {}, environment: {} }
+    },
+    {
+        provide: APP_BASE_HREF, useValue: '/'
+    }
+  ],
+  bootstrap: [${componentName}],
+})
+export class AppModule {}
+`;
+};
+export const angularJsonFile = `
+{
+  "version": 1,
+  "newProjectRoot": "projects",
+  "projects": {
+    "demo": {
+      "root": "",
+      "sourceRoot": "",
+      "projectType": "application",
+      "prefix": "app",
+      "schematics": {},
+      "architect": {
+        "build": {
+          "builder": "@angular-devkit/build-angular:browser",
+          "options": {
+            "outputPath": "dist/demo",
+            "index": "src/index.html",
+            "main": "src/main.ts",
+            "polyfills": "src/polyfills.ts",
+            "tsConfig": "tsconfig.json",
+            "assets": [
+              {
+                "glob": "**/*",
+                "input": "./node_modules/@eui/styles-base/src/assets/",
+                "output": "src/assets"
+              },
+              {
+                "glob": "**/*",
+                "input": "./node_modules/@eui/core/assets/",
+                "output": "src/assets"
+              }
+            ],
+            "styles": [
+              "./node_modules/@eui/styles/dist/styles/eui.css"
+            ],
+            "scripts": [],
+            "preserveSymlinks": true
+          },
+          "configurations": {
+            "production": {
+              "optimization": true,
+              "outputHashing": "all",
+              "sourceMap": false,
+              "extractCss": true,
+              "namedChunks": false,
+              "aot": true,
+              "extractLicenses": true,
+              "vendorChunk": false,
+              "buildOptimizer": true
+            }
+          }
+        },
+        "serve": {
+          "builder": "@angular-devkit/build-angular:dev-server",
+          "options": {
+            "browserTarget": "demo:build"
+          },
+          "configurations": {
+            "production": {
+              "browserTarget": "demo:build:production"
+            }
+          }
+        },
+        "lint": {
+          "builder": "@angular-devkit/build-angular:tslint",
+          "options": {
+            "tsConfig": ["tsconfig.json"],
+            "exclude": ["**/node_modules/**"]
+          }
+        }
+      }
+    }
+  },
+  "defaultProject": "demo",
+  "cli": {
+    "analytics": "0f944abb-e787-4c1f-9092-e34292361c91"
+  }
+}
+`;
+export const indexHtmlFile = (selector) => `
+<!-- TODO: Find a workaround -->
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<link rel="stylesheet" href="assets/eui.css" />
+<!-- END TODO -->
+<${selector}>
+    <div id="loader-wrapper">
+        <div id="loader"></div>
+    </div>
+</${selector}>
+`;
+export const PACKAGE_JSON = {
+    name: 'demo',
+    version: '0.0.0',
+    private: true,
+    dependencies: {},
+};
+export const tsConfig = `
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "baseUrl": "./",
+    "outDir": "./dist/out-tsc",
+    "sourceMap": true,
+    "declaration": false,
+    "downlevelIteration": true,
+    "experimentalDecorators": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "importHelpers": true,
+    "target": "es2016",
+    "allowSyntheticDefaultImports": true,
+    "emitDecoratorMetadata": true,
+    "typeRoots": [
+      "node_modules/@types"
+    ],
+    "lib": [
+      "es2020",
+      "dom"
+    ]
+  },
+  "angularCompilerOptions": {
+    "enableIvy": true,
+    "fullTemplateTypeCheck": true,
+    "strictInjectionParameters": true
+  }
+}`;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stackblitz.files.js","sourceRoot":"","sources":["../../../../../src/lib/components/playground/stackblitz.files.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,aAAa,GAAG,6BAA6B,CAAC;AAC3D,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,UAAkB,EAAE,EAAE,CAAC;;;;WAIrC,UAAU;;sFAEiE,UAAU;;;;;;;;;;;CAW/F,CAAC;AACF,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,aAAqB,EAAE,IAAqC,EAAE,EAAE,EAAE;IACzF,OAAO;;;;;;;;;;;;;;;;;;;;;WAqBA,aAAa;CACvB,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG;;;;;;;;;;;;;;;;;KAiBnE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG;;mBAE3B,aAAa;;;;;;;;;;;;;;;gBAehB,aAAa;;;CAG5B,CAAC;AAEF,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8E9B,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,QAAgB,EAAE,EAAE,CAAC;;;;;GAKhD,QAAQ;;;;IAIP,QAAQ;CACX,CAAC;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IACxB,IAAI,EAAE,MAAM;IACZ,OAAO,EAAE,OAAO;IAChB,OAAO,EAAE,IAAI;IACb,YAAY,EAAE,EACb;CACJ,CAAC;AACF,MAAM,CAAC,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BtB,CAAC","sourcesContent":["export const polyfillsFile = `import 'zone.js/dist/zone';`;\nexport const mainFile = (moduleName: string) => `\nimport './polyfills';\nimport { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\nimport { preInitApp } from '@eui/core';\nimport { ${moduleName} } from './component';\n\npreInitApp({production: false}).then(() => platformBrowserDynamic().bootstrapModule(${moduleName}).then(ref => {\n      // Ensure Angular destroys itself on hot reloads.\n      if (window['ngRef']) {\n        window['ngRef'].destroy();\n      }\n      window['ngRef'] = ref;\n\n      // Otherwise, log the boot error\n    }).catch(err => console.error(err))\n);\n\n`;\nexport const moduleFile = (componentName: string, m: {name: string; path: string;}[] = []) => {\n    return `\nimport { NgModule, InjectionToken } from '@angular/core';\nimport { BrowserModule } from '@angular/platform-browser';\nimport { BrowserAnimationsModule } from '@angular/platform-browser/animations';\nimport { RouterModule } from '@angular/router';\nimport { APP_BASE_HREF } from '@angular/common';\nimport { HttpClientModule } from '@angular/common/http';\nimport { StoreModule } from '@ngrx/store';\nimport { EffectsModule } from '@ngrx/effects';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { FormsModule } from '@angular/forms';\nimport { CommonModule } from '@angular/common';\nimport { EuiAllModule } from '@eui/components';\nimport {\n    reducers as coreReducers,\n    CoreModule as EuiCoreModule,\n    translateConfig,\n    CoreModuleEffects,\n    EUI_CONFIG_TOKEN,\n} from '@eui/core';\n\nimport { ${componentName} } from './component';\n` + m.map((i) => `import { ${i.name} } from '${i.path}';\\n`).join('') + `\n\nexport const REDUCER_TOKEN = new InjectionToken<any>('Registered Reducers');\n\n@NgModule({\n  imports: [\n    BrowserAnimationsModule,\n    CommonModule,\n    BrowserModule,\n    FormsModule,\n    EuiAllModule,\n    HttpClientModule,\n    RouterModule.forRoot([]),\n    EuiCoreModule.forRoot(),\n    EffectsModule.forRoot([...CoreModuleEffects]),\n    TranslateModule.forRoot(translateConfig),\n    StoreModule.forRoot(REDUCER_TOKEN, { })\n    ` + m.map((i) => `${i.name},`).join('') + `\n  ],\n  declarations: [${componentName}],\n  providers: [\n    {\n        provide: REDUCER_TOKEN,\n        deps: [],\n        useFactory: () => Object.assign({}, coreReducers),\n    },\n    {\n        provide: EUI_CONFIG_TOKEN,\n        useValue: { appConfig: {}, environment: {} }\n    },\n    {\n        provide: APP_BASE_HREF, useValue: '/'\n    }\n  ],\n  bootstrap: [${componentName}],\n})\nexport class AppModule {}\n`;\n\n};\nexport const angularJsonFile = `\n{\n  \"version\": 1,\n  \"newProjectRoot\": \"projects\",\n  \"projects\": {\n    \"demo\": {\n      \"root\": \"\",\n      \"sourceRoot\": \"\",\n      \"projectType\": \"application\",\n      \"prefix\": \"app\",\n      \"schematics\": {},\n      \"architect\": {\n        \"build\": {\n          \"builder\": \"@angular-devkit/build-angular:browser\",\n          \"options\": {\n            \"outputPath\": \"dist/demo\",\n            \"index\": \"src/index.html\",\n            \"main\": \"src/main.ts\",\n            \"polyfills\": \"src/polyfills.ts\",\n            \"tsConfig\": \"tsconfig.json\",\n            \"assets\": [\n              {\n                \"glob\": \"**/*\",\n                \"input\": \"./node_modules/@eui/styles-base/src/assets/\",\n                \"output\": \"src/assets\"\n              },\n              {\n                \"glob\": \"**/*\",\n                \"input\": \"./node_modules/@eui/core/assets/\",\n                \"output\": \"src/assets\"\n              }\n            ],\n            \"styles\": [\n              \"./node_modules/@eui/styles/dist/styles/eui.css\"\n            ],\n            \"scripts\": [],\n            \"preserveSymlinks\": true\n          },\n          \"configurations\": {\n            \"production\": {\n              \"optimization\": true,\n              \"outputHashing\": \"all\",\n              \"sourceMap\": false,\n              \"extractCss\": true,\n              \"namedChunks\": false,\n              \"aot\": true,\n              \"extractLicenses\": true,\n              \"vendorChunk\": false,\n              \"buildOptimizer\": true\n            }\n          }\n        },\n        \"serve\": {\n          \"builder\": \"@angular-devkit/build-angular:dev-server\",\n          \"options\": {\n            \"browserTarget\": \"demo:build\"\n          },\n          \"configurations\": {\n            \"production\": {\n              \"browserTarget\": \"demo:build:production\"\n            }\n          }\n        },\n        \"lint\": {\n          \"builder\": \"@angular-devkit/build-angular:tslint\",\n          \"options\": {\n            \"tsConfig\": [\"tsconfig.json\"],\n            \"exclude\": [\"**/node_modules/**\"]\n          }\n        }\n      }\n    }\n  },\n  \"defaultProject\": \"demo\",\n  \"cli\": {\n    \"analytics\": \"0f944abb-e787-4c1f-9092-e34292361c91\"\n  }\n}\n`;\nexport const indexHtmlFile = (selector: string) => `\n<!-- TODO: Find a workaround -->\n<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />\n<link rel=\"stylesheet\" href=\"assets/eui.css\" />\n<!-- END TODO -->\n<${selector}>\n    <div id=\"loader-wrapper\">\n        <div id=\"loader\"></div>\n    </div>\n</${selector}>\n`;\nexport const PACKAGE_JSON = {\n    name: 'demo',\n    version: '0.0.0',\n    private: true,\n    dependencies: {\n    },\n};\nexport const tsConfig = `\n{\n  \"compileOnSave\": false,\n  \"compilerOptions\": {\n    \"baseUrl\": \"./\",\n    \"outDir\": \"./dist/out-tsc\",\n    \"sourceMap\": true,\n    \"declaration\": false,\n    \"downlevelIteration\": true,\n    \"experimentalDecorators\": true,\n    \"module\": \"esnext\",\n    \"moduleResolution\": \"node\",\n    \"importHelpers\": true,\n    \"target\": \"es2016\",\n    \"allowSyntheticDefaultImports\": true,\n    \"emitDecoratorMetadata\": true,\n    \"typeRoots\": [\n      \"node_modules/@types\"\n    ],\n    \"lib\": [\n      \"es2020\",\n      \"dom\"\n    ]\n  },\n  \"angularCompilerOptions\": {\n    \"enableIvy\": true,\n    \"fullTemplateTypeCheck\": true,\n    \"strictInjectionParameters\": true\n  }\n}`;\n"]}

package/esm2020/lib/eui-showcase.module.mjs

@@ -7,6 +7,8 @@ import { EuiPageModule } from '@eui/components/eui-page';
 import { EuiChipModule } from '@eui/components/eui-chip';
 import { EuiDialogModule } from '@eui/components/eui-dialog';
 import { EuiAlertModule } from '@eui/components/eui-alert';
+import { EuiBlockContentModule } from '@eui/components/eui-block-content';
+import { EuiBadgeModule } from '@eui/components/eui-badge';
 import { DocPageComponent, DocPageOverviewContentDirective, DocPageSamplesContentDirective, DocPageApiContentDirective, DocPageInteractiveContentDirective, DocPageSectionsContentDirective, DocPageAccessibilityContentDirective, DocPageThemingContentDirective, } from './components/doc-page/doc-page.component';
 import { DocSampleComponent } from './components/doc-sample/doc-sample.component';
 import { DocSampleApiComponent } from './components/doc-sample-api/doc-sample-api.component';
@@ -14,7 +16,8 @@ import { DocSectionComponent } from './components/doc-section/doc-section.compon
 import { DocPageCodeComponent } from './components/doc-page-code/doc-page-code.component';
 import { EuiCodeHighlighterDirective } from './components/eui-code-highlighter/eui-code-highlighter.component';
 import { DocSectionCodeComponent, DocSectionCodeHtmlTagDirective, DocSectionCodeTsTagDirective, DocSectionCodeServiceTagDirective, DocSectionCodeCssTagDirective, DocSectionCodeDocTagDirective, DocSectionCodeDescriptionTagDirective, } from './components/doc-section-code/doc-section-code.component';
-import { DocPageCodeFabComponent, LoremIpsumSampleComponent } from './components';
+import { DocPageCodeFabComponent, LoremIpsumSampleComponent, PlaygroundComponent } from './components';
+import { DocPagePatternComponent, DocPagePatternDocDirective, DocPagePatternSampleDirective, } from './components/doc-page-pattern/doc-page-pattern.component';
 import * as i0 from "@angular/core";
 const COMPONENTS = [
     EuiCodeHighlighterDirective,
@@ -39,6 +42,10 @@ const COMPONENTS = [
     DocSectionCodeDocTagDirective,
     DocSectionCodeDescriptionTagDirective,
     LoremIpsumSampleComponent,
+    PlaygroundComponent,
+    DocPagePatternComponent,
+    DocPagePatternDocDirective,
+    DocPagePatternSampleDirective,
 ];
 export class EuiShowcaseModule {
 }
@@ -64,14 +71,20 @@ export class EuiShowcaseModule {
         DocSectionCodeCssTagDirective,
         DocSectionCodeDocTagDirective,
         DocSectionCodeDescriptionTagDirective,
-        LoremIpsumSampleComponent], imports: [CommonModule,
+        LoremIpsumSampleComponent,
+        PlaygroundComponent,
+        DocPagePatternComponent,
+        DocPagePatternDocDirective,
+        DocPagePatternSampleDirective], imports: [CommonModule,
         EuiCardModule,
         EuiButtonModule,
         EuiTabsModule,
         EuiPageModule,
         EuiChipModule,
         EuiDialogModule,
-        EuiAlertModule], exports: [EuiCodeHighlighterDirective,
+        EuiAlertModule,
+        EuiBlockContentModule,
+        EuiBadgeModule], exports: [EuiCodeHighlighterDirective,
         DocPageComponent,
         DocPageCodeComponent,
         DocPageCodeFabComponent,
@@ -92,7 +105,11 @@ export class EuiShowcaseModule {
         DocSectionCodeCssTagDirective,
         DocSectionCodeDocTagDirective,
         DocSectionCodeDescriptionTagDirective,
-        LoremIpsumSampleComponent] });
+        LoremIpsumSampleComponent,
+        PlaygroundComponent,
+        DocPagePatternComponent,
+        DocPagePatternDocDirective,
+        DocPagePatternSampleDirective] });
 /** @nocollapse */ EuiShowcaseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.0-next.4", ngImport: i0, type: EuiShowcaseModule, imports: [CommonModule,
         EuiCardModule,
         EuiButtonModule,
@@ -100,7 +117,9 @@ export class EuiShowcaseModule {
         EuiPageModule,
         EuiChipModule,
         EuiDialogModule,
-        EuiAlertModule] });
+        EuiAlertModule,
+        EuiBlockContentModule,
+        EuiBadgeModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0-next.4", ngImport: i0, type: EuiShowcaseModule, decorators: [{
             type: NgModule,
             args: [{
@@ -114,8 +133,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0-next.4",
                         EuiChipModule,
                         EuiDialogModule,
                         EuiAlertModule,
+                        EuiBlockContentModule,
+                        EuiBadgeModule,
                     ],
                     exports: [...COMPONENTS],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eui-showcase.module.js","sourceRoot":"","sources":["../../../src/lib/eui-showcase.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgModule } from '@angular/core';\nimport { CommonModule } from '@angular/common';\n\nimport { EuiCardModule } from '@eui/components/eui-card';\nimport { EuiButtonModule } from '@eui/components/eui-button';\nimport { EuiTabsModule } from '@eui/components/eui-tabs';\nimport { EuiPageModule } from '@eui/components/eui-page';\nimport { EuiChipModule } from '@eui/components/eui-chip';\nimport { EuiDialogModule } from '@eui/components/eui-dialog';\nimport { EuiAlertModule } from '@eui/components/eui-alert';\nimport { EuiBlockContentModule } from '@eui/components/eui-block-content';\nimport { EuiBadgeModule } from '@eui/components/eui-badge';\n\nimport {\n    DocPageComponent,\n    DocPageOverviewContentDirective,\n    DocPageSamplesContentDirective,\n    DocPageApiContentDirective,\n    DocPageInteractiveContentDirective,\n    DocPageSectionsContentDirective,\n    DocPageAccessibilityContentDirective,\n    DocPageThemingContentDirective,\n} from './components/doc-page/doc-page.component';\nimport { DocSampleComponent } from './components/doc-sample/doc-sample.component';\nimport { DocSampleApiComponent } from './components/doc-sample-api/doc-sample-api.component';\nimport { DocSectionComponent } from './components/doc-section/doc-section.component';\nimport { DocPageCodeComponent } from './components/doc-page-code/doc-page-code.component';\n\nimport { EuiCodeHighlighterDirective } from './components/eui-code-highlighter/eui-code-highlighter.component';\nimport {\n    DocSectionCodeComponent,\n    DocSectionCodeHtmlTagDirective,\n    DocSectionCodeTsTagDirective,\n    DocSectionCodeServiceTagDirective,\n    DocSectionCodeCssTagDirective,\n    DocSectionCodeDocTagDirective,\n    DocSectionCodeDescriptionTagDirective,\n} from './components/doc-section-code/doc-section-code.component';\nimport { DocPageCodeFabComponent, LoremIpsumSampleComponent, PlaygroundComponent } from './components';\nimport {\n    DocPagePatternComponent, DocPagePatternDocDirective, DocPagePatternSampleDirective,\n} from './components/doc-page-pattern/doc-page-pattern.component';\n\nconst COMPONENTS = [\n    EuiCodeHighlighterDirective,\n    DocPageComponent,\n    DocPageCodeComponent,\n    DocPageCodeFabComponent,\n    DocPageOverviewContentDirective,\n    DocPageApiContentDirective,\n    DocPageInteractiveContentDirective,\n    DocPageSamplesContentDirective,\n    DocPageSectionsContentDirective,\n    DocPageAccessibilityContentDirective,\n    DocPageThemingContentDirective,\n    DocSampleComponent,\n    DocSampleApiComponent,\n    DocSectionComponent,\n    DocSectionCodeComponent,\n    DocSectionCodeHtmlTagDirective,\n    DocSectionCodeTsTagDirective,\n    DocSectionCodeServiceTagDirective,\n    DocSectionCodeCssTagDirective,\n    DocSectionCodeDocTagDirective,\n    DocSectionCodeDescriptionTagDirective,\n    LoremIpsumSampleComponent,\n    PlaygroundComponent,\n    DocPagePatternComponent,\n    DocPagePatternDocDirective,\n    DocPagePatternSampleDirective,\n];\n\n@NgModule({\n    declarations: [...COMPONENTS],\n    imports: [\n        CommonModule,\n        EuiCardModule,\n        EuiButtonModule,\n        EuiTabsModule,\n        EuiPageModule,\n        EuiChipModule,\n        EuiDialogModule,\n        EuiAlertModule,\n        EuiBlockContentModule,\n        EuiBadgeModule,\n    ],\n    exports: [...COMPONENTS],\n})\nexport class EuiShowcaseModule { }\n"]}