wacom 21.1.8 → 21.1.9

package/fesm2022/wacom.mjs

@@ -1,13 +1,14 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, Inject, Optional, Injectable, signal, inject, ChangeDetectorRef, output, ElementRef, DestroyRef, Directive, input, effect, Pipe, isSignal, ApplicationRef, EnvironmentInjector, createComponent, makeEnvironmentProviders, NgModule } from '@angular/core';
 import * as i1 from '@angular/router';
+import { NavigationEnd } from '@angular/router';
+import { filter, first, catchError } from 'rxjs/operators';
 import * as i2 from '@angular/platform-browser';
 import { DomSanitizer } from '@angular/platform-browser';
-import { take, firstValueFrom, Subject, skip, takeUntil, share, filter, map, Observable, merge, combineLatest, timeout, ReplaySubject, EMPTY } from 'rxjs';
+import { take, firstValueFrom, Subject, skip, takeUntil, share, filter as filter$1, map, Observable, merge, combineLatest, timeout, ReplaySubject, EMPTY } from 'rxjs';
 import { toObservable } from '@angular/core/rxjs-interop';
 import * as i1$1 from '@angular/common/http';
 import { HttpHeaders, HttpErrorResponse, provideHttpClient, withInterceptorsFromDi } from '@angular/common/http';
-import { first, catchError } from 'rxjs/operators';
 import * as i1$2 from '@angular/common';
 import { CommonModule } from '@angular/common';
 import { FormsModule } from '@angular/forms';
@@ -19,7 +20,6 @@ const DEFAULT_CONFIG = {
     },
     meta: {
         useTitleSuffix: false,
-        warnMissingGuard: false,
         defaults: { links: {} },
     },
     socket: false,
@@ -51,216 +51,366 @@ const NETWORK_CONFIG = new InjectionToken('NETWORK_CONFIG', {
     factory: () => DEFAULT_NETWORK_CONFIG,
 });
 
+/**
+ * Utility helpers for meta management.
+ *
+ * We intentionally treat `undefined` as "missing" and everything else as "provided".
+ * This lets callers pass empty strings to intentionally clear a value:
+ * - isDefined(undefined) -> false  (use defaults)
+ * - isDefined('')        -> true   (explicitly set empty string)
+ * - isDefined(null)      -> true   (explicitly provided, will stringify if used)
+ */
 const isDefined = (val) => typeof val !== 'undefined';
+
+/**
+ * Centralized page meta management for SPA navigation.
+ *
+ * Goals:
+ * - Static SEO pages: route-driven meta via `data.meta`
+ * - Dynamic/id pages: manual meta via `applyMeta(...)`
+ * - No stale meta: tags set for one page must not "leak" to another page
+ * - Simple inputs: only title/description/image/index/robots (everything else auto-generated)
+ * - Links handled separately: `setLink({ canonical: '...' })` updates, never duplicates
+ *
+ * Generated tags:
+ * - Title:
+ *   - <title>
+ *   - <meta itemprop="name" ...>
+ *   - <meta property="og:title" ...>
+ *   - <meta name="twitter:title" ...>
+ * - Description:
+ *   - <meta name="description" ...>
+ *   - <meta itemprop="description" ...>
+ *   - <meta property="og:description" ...>
+ *   - <meta name="twitter:description" ...>
+ * - Image:
+ *   - <meta itemprop="image" ...>
+ *   - <meta property="og:image" ...>
+ *   - <meta name="twitter:image:src" ...>
+ * - Robots:
+ *   - <meta name="robots" ...> (derived from `robots` or `index`)
+ */
 class MetaService {
-    constructor(config, router, meta, titleService) {
+    constructor(config, router, activatedRoute, meta, titleService) {
         this.config = config;
         this.router = router;
+        this.activatedRoute = activatedRoute;
         this.meta = meta;
         this.titleService = titleService;
+        /**
+         * Meta tags that are "owned" by this service.
+         * We remove these on every `applyMeta()` so stale tags never survive SPA navigation.
+         *
+         * Stored as selectors compatible with Angular Meta.removeTag(), e.g.:
+         * - name="description"
+         * - property="og:title"
+         * - itemprop="image"
+         */
+        this.managedTagSelectors = new Set();
+        /**
+         * Link rels that are managed by this service.
+         * Used to update links without duplicates and optionally remove them via resetLinks().
+         */
+        this.managedLinkRels = new Set();
         this.config = this.config || DEFAULT_CONFIG;
-        this._meta = this.config.meta || {};
-        this._warnMissingGuard();
+        this.metaConfig = this.config.meta || {};
+        // Recommended default: keep meta in sync with route changes automatically.
+        const applyFromRoutes = !isDefined(this.metaConfig.applyFromRoutes) ||
+            !!this.metaConfig.applyFromRoutes;
+        if (applyFromRoutes) {
+            this.router.events
+                .pipe(filter((e) => e instanceof NavigationEnd))
+                .subscribe(() => {
+                const page = this._readDeepestRouteMeta();
+                if (page)
+                    this.applyMeta(page);
+                else
+                    this.reset();
+            });
+        }
     }
     /**
-     * Sets the default meta tags.
+     * Merge and set defaults.
      *
-     * @param defaults - The default meta tags.
+     * Defaults are used when a page does not provide a given field.
+     * This affects:
+     * - applyMeta() fallbacks
+     * - reset()
      */
     setDefaults(defaults) {
-        this._meta.defaults = {
-            ...this._meta.defaults,
+        this.metaConfig.defaults = {
+            ...(this.metaConfig.defaults || {}),
             ...defaults,
         };
     }
     /**
-     * Sets the title and optional title suffix.
+     * Apply metadata for the current page.
+     *
+     * Use cases:
+     * - Static SEO pages: route data (`data.meta`) when applyFromRoutes = true
+     * - Dynamic / id pages: call manually after loading entity data
+     *
+     * Rules:
+     * 1) remove tags previously managed by this service
+     * 2) start from defaults
+     * 3) override with page values
+     * 4) generate OG/Twitter/itemprop variants
+     */
+    applyMeta(page = {}) {
+        if (page.disableUpdate)
+            return;
+        // 1) Clean managed tags to prevent leaks between pages.
+        this._removeManagedTags();
+        // 2) Resolve values with defaults.
+        const defaults = this.metaConfig.defaults || {};
+        const title = this._resolveTitle(page, defaults);
+        const description = this._resolveValue(page.description, defaults.description);
+        const image = this._resolveValue(page.image, defaults.image);
+        const robots = this._resolveRobots(page, defaults);
+        // 3) Apply generated tags.
+        this._setTitleTriplet(title);
+        this._setDescriptionTriplet(description);
+        this._setImageTriplet(image);
+        // 4) Robots support (index/noindex).
+        if (isDefined(robots)) {
+            this._updateTag('robots', robots, 'name');
+        }
+        // Links are intentionally not applied here.
+        // Canonical strategy depends on your routing/domain policy, so use setLink(...) explicitly.
+    }
+    /**
+     * Reset page meta back to defaults.
      *
-     * @param title - The title to set.
-     * @param titleSuffix - The title suffix to append.
-     * @returns The MetaService instance.
-     */
-    setTitle(title, titleSuffix) {
-        let titleContent = isDefined(title)
-            ? title || ''
-            : this._meta.defaults?.['title'] || '';
-        if (this._meta.useTitleSuffix) {
-            titleContent += isDefined(titleSuffix)
-                ? titleSuffix
-                : this._meta.defaults?.['titleSuffix'] || '';
-        }
-        this._updateMetaTag('title', titleContent);
-        this._updateMetaTag('og:title', titleContent);
-        this._updateMetaTag('twitter:title', titleContent);
-        this.titleService.setTitle(titleContent);
-        return this;
-    }
-    /**
-     * Sets link tags.
+     * Removes all managed tags and re-applies defaults-only meta.
+     */
+    reset() {
+        this.applyMeta({});
+    }
+    /**
+     * Sets link tags (canonical, alternate, etc.) without duplicates.
      *
-     * @param links - The links to set.
-     * @returns The MetaService instance.
+     * For each rel:
+     * - if link[rel=rel] exists -> update href
+     * - else -> create it
+     * - if duplicates exist -> remove extras
      */
     setLink(links) {
-        Object.keys(links).forEach((rel) => {
-            let link = document.createElement('link');
-            link.setAttribute('rel', rel);
-            link.setAttribute('href', links[rel]);
-            document.head.appendChild(link);
-        });
-        return this;
+        if (!links || !Object.keys(links).length)
+            return;
+        for (const rel of Object.keys(links)) {
+            const href = links[rel];
+            const all = Array.from(document.head.querySelectorAll(`link[rel="${rel}"]`));
+            let link = all[0];
+            if (!link) {
+                link = document.createElement('link');
+                link.setAttribute('rel', rel);
+                document.head.appendChild(link);
+            }
+            else if (all.length > 1) {
+                for (let i = 1; i < all.length; i++)
+                    all[i].remove();
+            }
+            link.setAttribute('href', href);
+            this.managedLinkRels.add(rel);
+        }
     }
     /**
-     * Sets a meta tag.
+     * Removes link tags that were managed by this service via setLink().
      *
-     * @param tag - The meta tag name.
-     * @param value - The meta tag value.
-     * @param prop - The meta tag property.
+     * Note:
+     * - Not called by reset() because canonical often should persist for the whole app shell.
+     * - Call explicitly if you want to remove canonical/alternate links.
      */
-    setTag(tag, value, prop) {
-        if (tag === 'title' || tag === 'titleSuffix') {
-            throw new Error(`Attempt to set ${tag} through 'setTag': 'title' and 'titleSuffix' are reserved. Use 'MetaService.setTitle' instead.`);
+    resetLinks() {
+        for (const rel of this.managedLinkRels) {
+            const all = Array.from(document.head.querySelectorAll(`link[rel="${rel}"]`));
+            all.forEach((it) => it.remove());
         }
-        const content = (isDefined(value)
-            ? value || ''
-            : this._meta.defaults?.[tag] || '') + '';
-        this._updateMetaTag(tag, content, prop);
-        if (tag === 'description') {
-            this._updateMetaTag('og:description', content, prop);
-            this._updateMetaTag('twitter:description', content, prop);
+        this.managedLinkRels.clear();
+    }
+    // ---------------------------------------------------------------------------
+    // Internals: route meta extraction
+    // ---------------------------------------------------------------------------
+    /**
+     * Reads `data.meta` from the deepest activated route.
+     * This matches the common Angular pattern where child routes override parent routes.
+     */
+    _readDeepestRouteMeta() {
+        let route = this.activatedRoute;
+        while (route?.firstChild)
+            route = route.firstChild;
+        const data = route?.snapshot?.data;
+        const meta = data && data['meta'];
+        return meta || null;
+    }
+    // ---------------------------------------------------------------------------
+    // Internals: resolving values
+    // ---------------------------------------------------------------------------
+    /**
+     * Resolves title with optional suffix behavior.
+     */
+    _resolveTitle(page, defaults) {
+        let titleContent = this._resolveValue(page.title, defaults.title) || '';
+        if (this.metaConfig.useTitleSuffix) {
+            const suffix = isDefined(page.titleSuffix)
+                ? page.titleSuffix
+                : defaults.titleSuffix;
+            titleContent += suffix || '';
         }
+        return titleContent;
     }
     /**
-     * Updates a meta tag.
+     * Resolves robots value.
      *
-     * @param tag - The meta tag name.
-     * @param value - The meta tag value.
-     * @param prop - The meta tag property.
+     * Precedence:
+     * - explicit robots (page) > explicit robots (defaults)
+     * - index flag (page/defaults) -> generates "index, follow" or "noindex, follow"
+     * - undefined -> no robots tag set by this service
+     */
+    _resolveRobots(page, defaults) {
+        if (isDefined(page.robots))
+            return (page.robots || '') + '';
+        if (isDefined(defaults.robots))
+            return (defaults.robots || '') + '';
+        const index = isDefined(page.index) ? page.index : defaults.index;
+        if (!isDefined(index))
+            return undefined;
+        return index ? 'index, follow' : 'noindex, follow';
+    }
+    /**
+     * Resolves value with "undefined means missing" semantics.
+     * - undefined -> fallback
+     * - empty string -> explicit empty
+     */
+    _resolveValue(val, fallback) {
+        if (isDefined(val))
+            return (val || '') + '';
+        if (isDefined(fallback))
+            return (fallback || '') + '';
+        return undefined;
+    }
+    // ---------------------------------------------------------------------------
+    // Internals: generated tag groups
+    // ---------------------------------------------------------------------------
+    /**
+     * Applies title to:
+     * - document <title>
+     * - itemprop="name"
+     * - og:title
+     * - twitter:title
+     */
+    _setTitleTriplet(title) {
+        this.titleService.setTitle(title);
+        this._updateTag('og:title', title, 'property');
+        this._updateTag('twitter:title', title, 'name');
+        this._updateTag('name', title, 'itemprop');
+    }
+    /**
+     * Applies description to:
+     * - name="description"
+     * - itemprop="description"
+     * - og:description
+     * - twitter:description
+     */
+    _setDescriptionTriplet(description) {
+        if (!isDefined(description))
+            return;
+        const content = description;
+        this._updateTag('description', content, 'name');
+        this._updateTag('og:description', content, 'property');
+        this._updateTag('twitter:description', content, 'name');
+        this._updateTag('description', content, 'itemprop');
+    }
+    /**
+     * Applies image to:
+     * - itemprop="image"
+     * - og:image
+     * - twitter:image:src
      */
-    _updateMetaTag(tag, value, prop) {
-        prop =
-            prop ||
-                (tag.startsWith('og:') || tag.startsWith('twitter:')
-                    ? 'property'
-                    : 'name');
-        this.meta.updateTag({ [prop]: tag, content: value });
+    _setImageTriplet(image) {
+        if (!isDefined(image))
+            return;
+        const content = image;
+        this._updateTag('og:image', content, 'property');
+        this._updateTag('twitter:image:src', content, 'name');
+        this._updateTag('image', content, 'itemprop');
     }
+    // ---------------------------------------------------------------------------
+    // Internals: tag update + ownership tracking
+    // ---------------------------------------------------------------------------
     /**
-     * Removes a meta tag.
+     * Update a meta tag with deterministic selector.
+     *
+     * Why selector:
+     * - prevents duplicates
+     * - ensures updates target the correct attribute variant (name/property/itemprop)
      *
-     * @param tag - The meta tag name.
-     * @param prop - The meta tag property.
+     * Ownership tracking:
+     * - Every selector we touch is remembered in managedTagSelectors.
+     * - On next apply/reset we remove them to avoid stale meta across pages.
      */
-    removeTag(tag, prop) {
-        prop =
-            prop ||
-                (tag.startsWith('og:') || tag.startsWith('twitter:')
-                    ? 'property'
-                    : 'name');
-        this.meta.removeTag(`${prop}="${tag}"`);
+    _updateTag(key, content, attr) {
+        const selector = attr === 'itemprop' ? `itemprop="${key}"` : `${attr}="${key}"`;
+        const tagDef = attr === 'itemprop'
+            ? { itemprop: key, content }
+            : { [attr]: key, content };
+        this.meta.updateTag(tagDef, selector);
+        this.managedTagSelectors.add(selector);
     }
     /**
-     * Warns about missing meta guards in routes.
+     * Remove all meta tags managed by this service.
+     * Called on each apply/reset to prevent tags from a previous page persisting.
      */
-    _warnMissingGuard() {
-        if (isDefined(this._meta.warnMissingGuard) &&
-            !this._meta.warnMissingGuard) {
-            return;
-        }
-        const hasDefaultMeta = !!Object.keys(this._meta.defaults ?? {}).length;
-        const hasMetaGuardInArr = (it) => it && it.IDENTIFIER === 'MetaGuard';
-        let hasShownWarnings = false;
-        const checkRoute = (route) => {
-            const hasRouteMeta = route.data && route.data['meta'];
-            const showWarning = !isDefined(route.redirectTo) &&
-                (hasDefaultMeta || hasRouteMeta) &&
-                !(route.canActivate || []).some(hasMetaGuardInArr);
-            if (showWarning) {
-                console.warn(`Route with path "${route.path}" has ${hasRouteMeta ? '' : 'default '}meta tags, but does not use MetaGuard. Please add MetaGuard to the canActivate array in your route configuration`);
-                hasShownWarnings = true;
-            }
-            (route.children || []).forEach(checkRoute);
-        };
-        this.router.config.forEach(checkRoute);
-        if (hasShownWarnings) {
-            console.warn(`To disable these warnings, set metaConfig.warnMissingGuard: false in your MetaConfig passed to MetaModule.forRoot()`);
+    _removeManagedTags() {
+        for (const selector of this.managedTagSelectors) {
+            this.meta.removeTag(selector);
         }
+        this.managedTagSelectors.clear();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.0", ngImport: i0, type: MetaService, deps: [{ token: CONFIG_TOKEN, optional: true }, { token: i1.Router }, { token: i2.Meta }, { token: i2.Title }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.0", ngImport: i0, type: MetaService, deps: [{ token: CONFIG_TOKEN, optional: true }, { token: i1.Router }, { token: i1.ActivatedRoute }, { token: i2.Meta }, { token: i2.Title }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.0", ngImport: i0, type: MetaService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.0", ngImport: i0, type: MetaService, decorators: [{
             type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
+            args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [CONFIG_TOKEN]
                 }, {
                     type: Optional
-                }] }, { type: i1.Router }, { type: i2.Meta }, { type: i2.Title }] });
+                }] }, { type: i1.Router }, { type: i1.ActivatedRoute }, { type: i2.Meta }, { type: i2.Title }] });
 
+/**
+ * Applies route-level metadata from `route.data.meta`.
+ *
+ * Usage:
+ * - Add this guard to routes that define `data.meta` to ensure meta is applied
+ *   as early as possible during activation.
+ *
+ * Note:
+ * - If `MetaConfig.applyFromRoutes` is enabled (recommended), the service will
+ *   also apply route meta automatically on NavigationEnd — even if this guard
+ *   is missing from some route definitions.
+ */
 class MetaGuard {
-    static { this.IDENTIFIER = 'MetaGuard'; }
-    constructor(metaService, config) {
+    constructor(metaService) {
         this.metaService = metaService;
-        this.config = config;
-        if (!this.config)
-            this.config = DEFAULT_CONFIG;
-        this._meta = this.config.meta || {};
-        this._meta.defaults = this._meta.defaults || {};
     }
-    canActivate(route, state) {
-        this._processRouteMetaTags(route.data && route.data['meta']);
+    canActivate(route) {
+        const pageMeta = (route.data && route.data['meta']) || null;
+        if (pageMeta)
+            this.metaService.applyMeta(pageMeta);
+        else
+            this.metaService.reset();
         return true;
     }
-    _processRouteMetaTags(meta = {}) {
-        if (meta.disableUpdate) {
-            return;
-        }
-        if (meta.title) {
-            this.metaService.setTitle(meta.title, meta.titleSuffix);
-        }
-        if (meta.links && Object.keys(meta.links).length) {
-            this.metaService.setLink(meta.links);
-        }
-        if (this._meta.defaults?.links &&
-            Object.keys(this._meta.defaults.links).length) {
-            this.metaService.setLink(this._meta.defaults.links);
-        }
-        Object.keys(meta).forEach((prop) => {
-            if (prop === 'title' ||
-                prop === 'titleSuffix' ||
-                prop === 'links') {
-                return;
-            }
-            Object.keys(meta[prop]).forEach((key) => {
-                this.metaService.setTag(key, meta[prop][key], prop);
-            });
-        });
-        Object.keys(this._meta.defaults).forEach((key) => {
-            if (key in meta ||
-                key === 'title' ||
-                key === 'titleSuffix' ||
-                key === 'links') {
-                return;
-            }
-            this.metaService.setTag(key, this._meta.defaults[key]);
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.0", ngImport: i0, type: MetaGuard, deps: [{ token: MetaService }, { token: CONFIG_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.0", ngImport: i0, type: MetaGuard, deps: [{ token: MetaService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.0", ngImport: i0, type: MetaGuard, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.0", ngImport: i0, type: MetaGuard, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: MetaService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [CONFIG_TOKEN]
-                }, {
-                    type: Optional
-                }] }] });
+        }], ctorParameters: () => [{ type: MetaService }] });
 
 // Core utilities and helpers for the Wacom app
 // Add capitalize method to String prototype if it doesn't already exist
@@ -1446,7 +1596,7 @@ class EmitterService {
     }
     onComplete(tasks, opts) {
         const list = (Array.isArray(tasks) ? tasks : [tasks]).filter(Boolean);
-        const streams = list.map((id) => toObservable(this._getDoneSignal(id)).pipe(filter((v) => v !== undefined), map((v) => v)));
+        const streams = list.map((id) => toObservable(this._getDoneSignal(id)).pipe(filter$1((v) => v !== undefined), map((v) => v)));
         let source$;
         if (list.length <= 1) {
             // single-task await