@dotglitch/ngx-common 3.0.0-beta.1 → 3.0.0-beta.2

package/esm2022/core/components/lazy-loader/lazy-loader.service.mjs

@@ -0,0 +1,216 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { stringToSlug } from '../../utils';
+import { ComponentResolveStrategy } from './types';
+import * as i0 from "@angular/core";
+// Monkey-patch the type of these symbols.
+const $id = Symbol("id");
+const $group = Symbol("group");
+export const NGX_LAZY_LOADER_CONFIG = new InjectionToken('lazyloader-config');
+export class LazyLoaderService {
+    get err() { return LazyLoaderService.config.logger.err; }
+    get log() { return LazyLoaderService.config.logger.log; }
+    get warn() { return LazyLoaderService.config.logger.warn; }
+    // A proxied registry that mutates reference keys
+    static { this.registry = {}; }
+    constructor(config = {}) {
+        // Ensure this is singleton and works regardless of special instancing requirements.
+        LazyLoaderService.configure(config);
+    }
+    static configure(config) {
+        this.config = {
+            componentResolveStrategy: ComponentResolveStrategy.PickFirst,
+            logger: {
+                log: console.log,
+                warn: console.warn,
+                err: console.error
+            },
+            ...config
+        };
+        config?.entries?.forEach(e => this.addComponentToRegistry(e));
+        // If a custom resolution strategy is provided but no resolution function is passed,
+        // we throw an error
+        if (this.config.componentResolveStrategy == ComponentResolveStrategy.Custom &&
+            !this.config.customResolver) {
+            throw new Error("Cannot initialize. Configuration specifies a custom resolve matcher but none was provided");
+        }
+        if (this.config.loaderDistractorComponent && this.config.loaderDistractorTemplate)
+            throw new Error("Cannot have both a Component and Template for Distractor view.");
+        if (this.config.errorComponent && this.config.errorTemplate)
+            throw new Error("Cannot have both a Component and Template for Error view.");
+        if (this.config.notFoundComponent && this.config.notFoundTemplate)
+            throw new Error("Cannot have both a Component and Template for NotFound view.");
+    }
+    static addComponentToRegistry(registration) {
+        if (!registration)
+            throw new Error("Cannot add <undefined> component into registry.");
+        // Clone the object into our repository and transfer the id into a standardized slug format
+        const id = stringToSlug(registration.id ?? Date.now().toString()); // purge non-basic ASCII chars
+        const group = registration.group || "default";
+        registration[$id] = id;
+        registration[$group] = id;
+        if (!this.registry[group])
+            this.registry[group] = [];
+        // Check if we already have a registration for the component
+        // if (this.registry[group] && typeof this.registry[group]['load'] == "function") {
+        //     // Warn the developer that the state is problematic
+        //     this.config.logger.warn(
+        //         `A previous entry already exists for ${id}! The old registration will be overridden.` +
+        //         `Please ensure you use groups if you intend to have duplicate component ids. ` +
+        //         `If this was intentional, first remove the old component from the registry before adding a new instance`
+        //     );
+        //     // If we're in dev mode, break the loader surface
+        //     if (isDevMode())
+        //         return;
+        // }
+        this.registry[group].push(registration);
+    }
+    /**
+     * Register an Angular component
+     * @param id identifier that is used to resolve the component
+     * @param group
+     * @param component Angular Component Class constructor
+     */
+    registerComponent(args) {
+        if (this.isComponentRegistered(args.id, args.group)) {
+            this.log(`Will not re-register component '${args.id}' in group '${args.group || 'default'}' `);
+            return;
+        }
+        LazyLoaderService.addComponentToRegistry({
+            id: stringToSlug(args.id),
+            matcher: args.matcher,
+            group: stringToSlug(args.group || "default"),
+            load: args.load || (() => args.component)
+        });
+    }
+    /**
+     *
+     * @param id
+     * @param group
+     */
+    unregisterComponent(id, group = "default") {
+        const _id = stringToSlug(id);
+        const _group = stringToSlug(group);
+        if (!this.resolveRegistrationEntry(id, group))
+            throw new Error("Cannot unregister component ${}! Component is not present in registry");
+        // TODO: handle clearing running instances
+        delete LazyLoaderService.registry[_group][_id];
+    }
+    /**
+     * Get the registration entry for a component.
+     * Returns null if component is not in the registry.
+     */
+    resolveRegistrationEntry(value, group = "default") {
+        const _id = stringToSlug(value);
+        const _group = stringToSlug(group);
+        const targetGroup = (LazyLoaderService.registry[_group] || []);
+        let items = targetGroup.filter(t => {
+            if (!t)
+                return false;
+            // No matcher, check id
+            if (!t.matcher)
+                return t.id == value || t[$id] == _id;
+            // Matcher is regex
+            if (t.matcher instanceof RegExp)
+                return t.matcher.test(value) || t.matcher.test(_id);
+            // Matcher is string => regex
+            if (typeof t.matcher == 'string') {
+                const rx = new RegExp(t.matcher, 'ui');
+                return rx.test(value) || rx.test(_id);
+            }
+            // Matcher is array
+            if (Array.isArray(t.matcher)) {
+                return !!t.matcher.find(e => stringToSlug(e) == _id);
+            }
+            // Custom matcher function
+            if (typeof t.matcher == "function")
+                return t.matcher(_id);
+            return false;
+        });
+        if (items.length > 1) {
+            this.warn("Resolved multiple components for the provided `[component]` binding. This may cause UI conflicts.");
+        }
+        if (items.length == 0) {
+            return null;
+        }
+        const out = items[0];
+        if (out.matcher instanceof RegExp) {
+            const result = value.match(out.matcher) || _id.match(out.matcher);
+            return {
+                entry: out,
+                matchGroups: result?.groups
+            };
+        }
+        return { entry: out };
+    }
+    /**
+     * Check if a component is currently registered
+     * Can be used to validate regex matchers and aliases.
+     */
+    isComponentRegistered(value, group = "default") {
+        return !!this.resolveRegistrationEntry(value, group);
+    }
+    /**
+     *
+     * @param bundle
+     * @returns The component `Object` if a component was resolved, `null` if no component was found
+     * `false` if the specified strategy was an invalid selection
+     */
+    resolveComponent(id, group, modules) {
+        switch (LazyLoaderService.config.componentResolveStrategy) {
+            case ComponentResolveStrategy.PickFirst: {
+                return modules[0];
+            }
+            // Exact id -> classname match
+            case ComponentResolveStrategy.MatchIdToClassName: {
+                const matches = modules
+                    .filter(k => k.name == id);
+                if (matches.length == 0)
+                    return null;
+                return matches[0];
+            }
+            // Fuzzy id -> classname match
+            case ComponentResolveStrategy.FuzzyIdClassName: {
+                const _id = id.replace(/[^a-z0-9_\-]/ig, '');
+                if (_id.length == 0) {
+                    LazyLoaderService.config.logger.err("Fuzzy classname matching stripped all symbols from the ID specified!");
+                    return false;
+                }
+                const rx = new RegExp(`^${id}(component|module)?$`, "i");
+                const matches = modules
+                    .filter(mod => {
+                    let kid = mod.name.replace(/[^a-z0-9_\-]/ig, '');
+                    return rx.test(kid);
+                });
+                if (matches.length > 1) {
+                    LazyLoaderService.config.logger.err("Fuzzy classname matching resolved multiple targets!");
+                    return false;
+                }
+                if (matches.length == 0) {
+                    LazyLoaderService.config.logger.err("Fuzzy classname matching resolved no targets!");
+                    return null;
+                }
+                return matches[0];
+            }
+            case ComponentResolveStrategy.Custom: {
+                return LazyLoaderService.config.customResolver(modules);
+            }
+            default: {
+                return false;
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LazyLoaderService, deps: [{ token: NGX_LAZY_LOADER_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LazyLoaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LazyLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [NGX_LAZY_LOADER_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lazy-loader.service.js","sourceRoot":"","sources":["../../../../../packages/common/core/components/lazy-loader/lazy-loader.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\nimport { stringToSlug } from '../../utils';\nimport { CompiledComponent, CompiledModule, ComponentRegistration, ComponentResolveStrategy, DynamicRegistrationArgs, NgxLazyLoaderConfig } from './types';\n\n// Monkey-patch the type of these symbols.\nconst $id = Symbol(\"id\") as any as string;\nconst $group = Symbol(\"group\") as any as string;\n\nexport const NGX_LAZY_LOADER_CONFIG = new InjectionToken<NgxLazyLoaderConfig>('lazyloader-config');\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class LazyLoaderService {\n    private get err() { return LazyLoaderService.config.logger.err; }\n    private get log() { return LazyLoaderService.config.logger.log; }\n    private get warn() { return LazyLoaderService.config.logger.warn; }\n\n    // A proxied registry that mutates reference keys\n    private static registry: {\n        [key: string]: ComponentRegistration[];\n    } = {};\n\n    public static config: NgxLazyLoaderConfig;\n\n    constructor(@Optional() @Inject(NGX_LAZY_LOADER_CONFIG) config: NgxLazyLoaderConfig = {}) {\n        // Ensure this is singleton and works regardless of special instancing requirements.\n        LazyLoaderService.configure(config);\n    }\n\n    private static configure(config: NgxLazyLoaderConfig) {\n        this.config = {\n            componentResolveStrategy: ComponentResolveStrategy.PickFirst,\n            logger: {\n                log: console.log,\n                warn: console.warn,\n                err: console.error\n            },\n            ...config\n        };\n\n        config?.entries?.forEach(e => this.addComponentToRegistry(e));\n\n        // If a custom resolution strategy is provided but no resolution function is passed,\n        // we throw an error\n        if (\n            this.config.componentResolveStrategy == ComponentResolveStrategy.Custom &&\n            !this.config.customResolver\n        ) {\n            throw new Error(\"Cannot initialize. Configuration specifies a custom resolve matcher but none was provided\");\n        }\n\n        if (this.config.loaderDistractorComponent && this.config.loaderDistractorTemplate)\n            throw new Error(\"Cannot have both a Component and Template for Distractor view.\");\n        if (this.config.errorComponent && this.config.errorTemplate)\n            throw new Error(\"Cannot have both a Component and Template for Error view.\");\n        if (this.config.notFoundComponent && this.config.notFoundTemplate)\n            throw new Error(\"Cannot have both a Component and Template for NotFound view.\");\n\n    }\n\n    private static addComponentToRegistry(registration: ComponentRegistration) {\n        if (!registration)\n            throw new Error(\"Cannot add <undefined> component into registry.\");\n\n        // Clone the object into our repository and transfer the id into a standardized slug format\n\n        const id = stringToSlug(registration.id ?? Date.now().toString()); // purge non-basic ASCII chars\n        const group = registration.group || \"default\";\n\n        registration[$id] = id;\n        registration[$group] = id;\n\n\n        if (!this.registry[group])\n            this.registry[group] = [];\n\n        // Check if we already have a registration for the component\n        // if (this.registry[group] && typeof this.registry[group]['load'] == \"function\") {\n        //     // Warn the developer that the state is problematic\n        //     this.config.logger.warn(\n        //         `A previous entry already exists for ${id}! The old registration will be overridden.` +\n        //         `Please ensure you use groups if you intend to have duplicate component ids. ` +\n        //         `If this was intentional, first remove the old component from the registry before adding a new instance`\n        //     );\n\n        //     // If we're in dev mode, break the loader surface\n        //     if (isDevMode())\n        //         return;\n        // }\n\n        this.registry[group].push(registration);\n    }\n\n    /**\n     * Register an Angular component\n     * @param id identifier that is used to resolve the component\n     * @param group\n     * @param component Angular Component Class constructor\n     */\n    public registerComponent<T extends { new(...args: any[]): InstanceType<T>; }>(args: DynamicRegistrationArgs<T>) {\n        if (this.isComponentRegistered(args.id, args.group)) {\n            this.log(`Will not re-register component '${args.id}' in group '${args.group || 'default'}' `);\n            return;\n        }\n\n        LazyLoaderService.addComponentToRegistry({\n            id: stringToSlug(args.id),\n            matcher: args.matcher,\n            group: stringToSlug(args.group || \"default\"),\n            load: args.load || (() => args.component)\n        });\n    }\n\n    /**\n     *\n     * @param id\n     * @param group\n     */\n    public unregisterComponent(id: string, group = \"default\") {\n        const _id = stringToSlug(id);\n        const _group = stringToSlug(group);\n\n        if (!this.resolveRegistrationEntry(id, group))\n            throw new Error(\"Cannot unregister component ${}! Component is not present in registry\");\n\n        // TODO: handle clearing running instances\n        delete LazyLoaderService.registry[_group][_id];\n    }\n\n\n    /**\n     * Get the registration entry for a component.\n     * Returns null if component is not in the registry.\n     */\n    public resolveRegistrationEntry(value: string, group = \"default\") {\n        const _id = stringToSlug(value);\n        const _group = stringToSlug(group);\n\n        const targetGroup = (LazyLoaderService.registry[_group] || []);\n\n        let items = targetGroup.filter(t => {\n            if (!t) return false;\n\n            // No matcher, check id\n            if (!t.matcher)\n                return t.id == value || t[$id] == _id;\n\n            // Matcher is regex\n            if (t.matcher instanceof RegExp)\n                return t.matcher.test(value) || t.matcher.test(_id);\n\n            // Matcher is string => regex\n            if (typeof t.matcher == 'string') {\n                const rx = new RegExp(t.matcher, 'ui');\n                return rx.test(value) || rx.test(_id);\n            }\n\n            // Matcher is array\n            if (Array.isArray(t.matcher)) {\n                return !!t.matcher.find(e => stringToSlug(e) == _id);\n            }\n\n            // Custom matcher function\n            if (typeof t.matcher == \"function\")\n                return t.matcher(_id);\n\n            return false;\n        });\n\n        if (items.length > 1) {\n            this.warn(\"Resolved multiple components for the provided `[component]` binding. This may cause UI conflicts.\");\n        }\n        if (items.length == 0) {\n            return null;\n        }\n\n        const out = items[0];\n\n        if (out.matcher instanceof RegExp) {\n            const result = value.match(out.matcher) || _id.match(out.matcher);\n\n            return {\n                entry: out,\n                matchGroups: result?.groups\n            };\n        }\n\n        return { entry: out };\n    }\n\n    /**\n     * Check if a component is currently registered\n     * Can be used to validate regex matchers and aliases.\n     */\n    public isComponentRegistered(value: string, group = \"default\") {\n        return !!this.resolveRegistrationEntry(value, group);\n    }\n\n    /**\n     *\n     * @param bundle\n     * @returns The component `Object` if a component was resolved, `null` if no component was found\n     * `false` if the specified strategy was an invalid selection\n     */\n    public resolveComponent(id: string, group: string, modules: (CompiledComponent | CompiledModule)[]): Object | null | false {\n\n        switch (LazyLoaderService.config.componentResolveStrategy) {\n            case ComponentResolveStrategy.PickFirst: {\n\n                return modules[0];\n            }\n\n            // Exact id -> classname match\n            case ComponentResolveStrategy.MatchIdToClassName: {\n                const matches =\n                    modules\n                        .filter(k => k.name == id);\n\n                if (matches.length == 0)\n                    return null;\n\n                return matches[0];\n            }\n            // Fuzzy id -> classname match\n            case ComponentResolveStrategy.FuzzyIdClassName: {\n                const _id = id.replace(/[^a-z0-9_\\-]/ig, '');\n\n                if (_id.length == 0) {\n                    LazyLoaderService.config.logger.err(\"Fuzzy classname matching stripped all symbols from the ID specified!\");\n                    return false;\n                }\n\n                const rx = new RegExp(`^${id}(component|module)?$`, \"i\");\n\n                const matches = modules\n                    .filter(mod => {\n                        let kid = mod.name.replace(/[^a-z0-9_\\-]/ig, '');\n\n                        return rx.test(kid);\n                    });\n\n                if (matches.length > 1) {\n                    LazyLoaderService.config.logger.err(\"Fuzzy classname matching resolved multiple targets!\");\n                    return false;\n                }\n\n                if (matches.length == 0) {\n                    LazyLoaderService.config.logger.err(\"Fuzzy classname matching resolved no targets!\");\n                    return null;\n                }\n\n                return matches[0];\n            }\n            case ComponentResolveStrategy.Custom: {\n                return LazyLoaderService.config.customResolver(modules as any);\n            }\n            default: {\n                return false;\n            }\n        }\n    }\n}\n"]}

package/esm2022/core/components/lazy-loader/types.mjs

@@ -0,0 +1,26 @@
+export var ComponentResolveStrategy;
+(function (ComponentResolveStrategy) {
+    /**
+     * Match the fist component we find
+     * (best used for standalone components)
+     * @default
+     */
+    ComponentResolveStrategy[ComponentResolveStrategy["PickFirst"] = 0] = "PickFirst";
+    /**
+     * Perform an Exact ID to Classname of the Component
+     * case sensitive, zero tolerance.
+     */
+    ComponentResolveStrategy[ComponentResolveStrategy["MatchIdToClassName"] = 1] = "MatchIdToClassName";
+    /**
+     * Perform a fuzzy ID to classname match
+     * case insensitive, mutes symbols
+     * ignores "Component" and "Module" postfixes on class
+     * names
+     */
+    ComponentResolveStrategy[ComponentResolveStrategy["FuzzyIdClassName"] = 2] = "FuzzyIdClassName";
+    /**
+     * Use a user-provided component match function
+     */
+    ComponentResolveStrategy[ComponentResolveStrategy["Custom"] = 3] = "Custom";
+})(ComponentResolveStrategy || (ComponentResolveStrategy = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vY29yZS9jb21wb25lbnRzL2xhenktbG9hZGVyL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sQ0FBTixJQUFZLHdCQXdCWDtBQXhCRCxXQUFZLHdCQUF3QjtJQUNoQzs7OztPQUlHO0lBQ0gsaUZBQVMsQ0FBQTtJQUNUOzs7T0FHRztJQUNILG1HQUFrQixDQUFBO0lBQ2xCOzs7OztPQUtHO0lBQ0gsK0ZBQWdCLENBQUE7SUFFaEI7O09BRUc7SUFDSCwyRUFBTSxDQUFBO0FBQ1YsQ0FBQyxFQXhCVyx3QkFBd0IsS0FBeEIsd0JBQXdCLFFBd0JuQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudFR5cGUgfSBmcm9tICdAYW5ndWxhci9jZGsvcG9ydGFsJztcbmltcG9ydCB7IFRlbXBsYXRlUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBlbnVtIENvbXBvbmVudFJlc29sdmVTdHJhdGVneSB7XG4gICAgLyoqXG4gICAgICogTWF0Y2ggdGhlIGZpc3QgY29tcG9uZW50IHdlIGZpbmRcbiAgICAgKiAoYmVzdCB1c2VkIGZvciBzdGFuZGFsb25lIGNvbXBvbmVudHMpXG4gICAgICogQGRlZmF1bHRcbiAgICAgKi9cbiAgICBQaWNrRmlyc3QsXG4gICAgLyoqXG4gICAgICogUGVyZm9ybSBhbiBFeGFjdCBJRCB0byBDbGFzc25hbWUgb2YgdGhlIENvbXBvbmVudFxuICAgICAqIGNhc2Ugc2Vuc2l0aXZlLCB6ZXJvIHRvbGVyYW5jZS5cbiAgICAgKi9cbiAgICBNYXRjaElkVG9DbGFzc05hbWUsXG4gICAgLyoqXG4gICAgICogUGVyZm9ybSBhIGZ1enp5IElEIHRvIGNsYXNzbmFtZSBtYXRjaFxuICAgICAqIGNhc2UgaW5zZW5zaXRpdmUsIG11dGVzIHN5bWJvbHNcbiAgICAgKiBpZ25vcmVzIFwiQ29tcG9uZW50XCIgYW5kIFwiTW9kdWxlXCIgcG9zdGZpeGVzIG9uIGNsYXNzXG4gICAgICogbmFtZXNcbiAgICAgKi9cbiAgICBGdXp6eUlkQ2xhc3NOYW1lLFxuXG4gICAgLyoqXG4gICAgICogVXNlIGEgdXNlci1wcm92aWRlZCBjb21wb25lbnQgbWF0Y2ggZnVuY3Rpb25cbiAgICAgKi9cbiAgICBDdXN0b21cbn1cblxuZXhwb3J0IHR5cGUgTmd4TGF6eUxvYWRlckNvbmZpZyA9IFBhcnRpYWw8e1xuICAgIGVudHJpZXM6IENvbXBvbmVudFJlZ2lzdHJhdGlvbltdLFxuXG4gICAgbm90Rm91bmRUZW1wbGF0ZTogVGVtcGxhdGVSZWY8YW55PixcbiAgICBub3RGb3VuZENvbXBvbmVudDogQ29tcG9uZW50VHlwZTxhbnk+LFxuXG4gICAgZXJyb3JUZW1wbGF0ZTogVGVtcGxhdGVSZWY8YW55PixcbiAgICBlcnJvckNvbXBvbmVudDogQ29tcG9uZW50VHlwZTxhbnk+LFxuXG4gICAgbG9hZGVyRGlzdHJhY3RvclRlbXBsYXRlOiBUZW1wbGF0ZVJlZjxhbnk+LFxuICAgIGxvYWRlckRpc3RyYWN0b3JDb21wb25lbnQ6IENvbXBvbmVudFR5cGU8YW55PixcblxuICAgIGxvZ2dlcjoge1xuICAgICAgICBsb2c6ICguLi5hcmdzOiBhbnkpID0+IHZvaWQsXG4gICAgICAgIHdhcm46ICguLi5hcmdzOiBhbnkpID0+IHZvaWQsXG4gICAgICAgIGVycjogKC4uLmFyZ3M6IGFueSkgPT4gdm9pZDtcbiAgICB9LFxuICAgIC8qKlxuICAgICAqIFdoYXQgc3RyYXRlZ3kgc2hvdWxkIGJlIHVzZWQgdG8gcmVzb2x2ZSBjb21wb25lbnRzXG4gICAgICogQGRlZmF1bHQgQ29tcG9uZW50UmVzb2x2ZVN0cmF0ZWd5LkZ1enp5SWRDbGFzc05hbWVcbiAgICAgKi9cbiAgICBjb21wb25lbnRSZXNvbHZlU3RyYXRlZ3k6IENvbXBvbmVudFJlc29sdmVTdHJhdGVneSxcbiAgICBjdXN0b21SZXNvbHZlcjogKHJlZ2lzdHJ5OiAoQ29tcGlsZWRDb21wb25lbnQgfCBDb21waWxlZE1vZHVsZSlbXSkgPT4gT2JqZWN0XG59PjtcblxudHlwZSBSZWdpc3RyYXRpb25Db25maWcgPSB7XG4gICAgLyoqXG4gICAgICogU3BlY2lmeSBhIGdyb3VwIHRvIGNhdGVnb3JpemUgY29tcG9uZW50cy4gSWYgbm90IHNwZWNpZmllZCxcbiAgICAgKiB3aWxsIGRlZmF1bHQgdG8gdGhlIGBkZWZhdWx0YCBncm91cC5cbiAgICAgKi9cbiAgICBncm91cD86IHN0cmluZyxcbiAgICAvKipcbiAgICAgKiBsb2FkOiAoKSA9PiBpbXBvcnQoJy4vcGFnZXMvbXktcGFnZS9teS1wYWdlLmNvbXBvbmVudCcpXG4gICAgICovXG4gICAgbG9hZDogKCkgPT4gYW55LFxuXG4gICAgLyoqXG4gICAgICogQ2FsbGVkIGJlZm9yZSBhIGNvbXBvbmVudCBpcyBsb2FkZWQuXG4gICAgICogSWYgaXQgcmV0dXJucyBgZmFsc2VgIHRoZSBjb21wb25lbnQgd2lsbCBub3QgYmUgbG9hZGVkLlxuICAgICAqL1xuICAgIC8vIGNhbkFjdGl2YXRlOiAoKSA9PiBib29sZWFuXG5cbiAgICBba2V5OiBzdHJpbmddOiBhbnlcbn1cblxuZXhwb3J0IHR5cGUgQ29tcG9uZW50UmVnaXN0cmF0aW9uID0gKFxuICAgICh7IGlkOiBzdHJpbmcgfSAmIFJlZ2lzdHJhdGlvbkNvbmZpZykgfFxuICAgICh7IG1hdGNoZXI6IHN0cmluZ1tdIHwgUmVnRXhwIHwgKCh2YWx1ZTogc3RyaW5nKSA9PiBib29sZWFuKTsgfSAmIFJlZ2lzdHJhdGlvbkNvbmZpZylcbik7XG5cbmV4cG9ydCB0eXBlIER5bmFtaWNSZWdpc3RyYXRpb25BcmdzPFQgPSBhbnk+ID0ge1xuICAgIGlkOiBzdHJpbmcsXG4gICAgZ3JvdXA/OiBzdHJpbmcsXG4gICAgbWF0Y2hlcj86IHN0cmluZ1tdIHwgUmVnRXhwIHwgKCh2YWw6IHN0cmluZykgPT4gYm9vbGVhbiksXG4gICAgY29tcG9uZW50PzogVCxcbiAgICBsb2FkPzogKCkgPT4gYW55O1xufVxuXG4vKipcbiAqIFRoaXMgaXMgcm91Z2hseSBhIGNvbXBpbGVkIGNvbXBvbmVudFxuICovXG5leHBvcnQgdHlwZSBDb21waWxlZENvbXBvbmVudCA9IHtcbiAgICAoKTogQ29tcGlsZWRDb21wb25lbnQsXG4gICAgybVmYWM6IEZ1bmN0aW9uLFxuICAgIMm1Y21wOiB7XG4gICAgICAgIGNvbnN0cztcbiAgICAgICAgY29udGVudFF1ZXJpZXM7XG4gICAgICAgIGRhdGE7XG4gICAgICAgIGRlY2xhcmVkSW5wdXRzO1xuICAgICAgICBkZWNscztcbiAgICAgICAgZGVwZW5kZW5jaWVzO1xuICAgICAgICBkaXJlY3RpdmVEZWZzO1xuICAgICAgICBlbmNhcHN1bGF0aW9uO1xuICAgICAgICBleHBvcnRBcztcbiAgICAgICAgZmFjdG9yeTtcbiAgICAgICAgZmVhdHVyZXM7XG4gICAgICAgIGZpbmRIb3N0RGlyZWN0aXZlRGVmcztcbiAgICAgICAgZ2V0U3RhbmRhbG9uZUluamVjdG9yO1xuICAgICAgICBob3N0QXR0cnM7XG4gICAgICAgIGhvc3RCaW5kaW5ncztcbiAgICAgICAgaG9zdERpcmVjdGl2ZXM7XG4gICAgICAgIGhvc3RWYXJzO1xuICAgICAgICBpZDogc3RyaW5nO1xuICAgICAgICBpbnB1dHM7XG4gICAgICAgIG5nQ29udGVudFNlbGVjdG9ycztcbiAgICAgICAgb25QdXNoOiBib29sZWFuO1xuICAgICAgICBvdXRwdXRzO1xuICAgICAgICBwaXBlRGVmcztcbiAgICAgICAgcHJvdmlkZXJzUmVzb2x2ZXI7XG4gICAgICAgIHNjaGVtYXM7XG4gICAgICAgIHNlbGVjdG9yczogc3RyaW5nW107XG4gICAgICAgIHNldElucHV0O1xuICAgICAgICBzdGFuZGFsb25lOiBib29sZWFuO1xuICAgICAgICBzdHlsZXM6IHN0cmluZ1tdO1xuICAgICAgICB0VmlldztcbiAgICAgICAgdGVtcGxhdGU7XG4gICAgICAgIHR5cGU6IEZ1bmN0aW9uO1xuICAgICAgICB2YXJzOiBudW1iZXI7XG4gICAgICAgIHZpZXdRdWVyeTtcbiAgICB9O1xufTtcblxuLyoqXG4gKiBUaGlzIGlzIHJvdWdobHkgYSBjb21waWxlZCBtb2R1bGVcbiAqL1xuZXhwb3J0IHR5cGUgQ29tcGlsZWRNb2R1bGUgPSB7XG4gICAgKCk6IENvbXBpbGVkTW9kdWxlLFxuICAgIMm1ZmFjOiBGdW5jdGlvbixcbiAgICDJtWluajoge1xuICAgICAgICBwcm92aWRlcnM6IGFueVtdLFxuICAgICAgICBpbXBvcnRzOiBhbnlbXTtcbiAgICB9LFxuICAgIMm1bW9kOiB7XG4gICAgICAgIGJvb3RzdHJhcDogYW55W10sXG4gICAgICAgIGRlY2xhcmF0aW9uczogRnVuY3Rpb25bXSxcbiAgICAgICAgZXhwb3J0czogYW55W10sXG4gICAgICAgIGlkOiB1bmtub3duLFxuICAgICAgICBpbXBvcnRzOiBhbnlbXSxcbiAgICAgICAgc2NoZW1hczogdW5rbm93bixcbiAgICAgICAgdHJhbnNpdGl2ZUNvbXBpbGVTY29wZXM6IHVua25vd24sXG4gICAgICAgIHR5cGU6IEZ1bmN0aW9uO1xuICAgIH07XG59O1xuXG5leHBvcnQgdHlwZSBDb21waWxlZEJ1bmRsZSA9IHsgW2tleTogc3RyaW5nXTogQ29tcGlsZWRDb21wb25lbnQgfCBDb21waWxlZE1vZHVsZTsgfTtcblxuXG4iXX0=