@dotglitch/ngx-common 1.0.2

package/esm2020/components/lazy-loader/lazy-loader.service.mjs

@@ -0,0 +1,215 @@
+import { Inject, Injectable, InjectionToken } from '@angular/core';
+import { ComponentResolveStrategy } from './types';
+import { stringToSlug, Logger } from '../../utils';
+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('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; }
+    constructor(config = {}) {
+        // Ensure this is singleton and works regardless of special instancing requirements.
+        LazyLoaderService.configure(config);
+    }
+    static configure(config) {
+        const { log, warn, err } = Logger("ngx-lazy-loader", "#009688");
+        this.config = {
+            componentResolveStrategy: ComponentResolveStrategy.PickFirst,
+            logger: {
+                log,
+                warn,
+                err
+            },
+            ...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] == _id;
+            // Matcher is regex
+            if (t.matcher instanceof RegExp)
+                return t.matcher.test(_id) || t.matcher.test(value);
+            // Matcher is string => regex
+            if (typeof t.matcher == 'string') {
+                const rx = new RegExp(t.matcher, 'ui');
+                return rx.test(_id) || rx.test(value);
+            }
+            // 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 = _id.match(out.matcher) || value.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;
+            }
+        }
+    }
+}
+// A proxied registry that mutates reference keys
+LazyLoaderService.registry = {};
+LazyLoaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LazyLoaderService, deps: [{ token: NGX_LAZY_LOADER_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+LazyLoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LazyLoaderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LazyLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NGX_LAZY_LOADER_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lazy-loader.service.js","sourceRoot":"","sources":["../../../../../packages/common/src/components/lazy-loader/lazy-loader.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken } from '@angular/core';\nimport { CompiledComponent, CompiledModule, ComponentRegistration, ComponentResolveStrategy, DynamicRegistrationArgs, NgxLazyLoaderConfig } from './types';\nimport { stringToSlug, Logger } from '../../utils';\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>('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(@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        const { log, warn, err } = Logger(\"ngx-lazy-loader\", \"#009688\");\n\n        this.config = {\n            componentResolveStrategy: ComponentResolveStrategy.PickFirst,\n            logger: {\n                log,\n                warn,\n                err\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] == _id;\n\n            // Matcher is regex\n            if (t.matcher instanceof RegExp)\n                return t.matcher.test(_id) || t.matcher.test(value);\n\n            // Matcher is string => regex\n            if (typeof t.matcher == 'string') {\n                const rx = new RegExp(t.matcher, 'ui');\n                return rx.test(_id) || rx.test(value);\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 = _id.match(out.matcher) || value.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/esm2020/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,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