@ssv/ngx.ux 2.0.0-dev175 → 2.0.2-dev.7

package/fesm2015/{ssv-ngx.ux.js → ssv-ngx.ux.mjs}

@@ -1,5 +1,6 @@
-import { InjectionToken, ɵɵdefineInjectable, ɵɵinject, Injectable, Inject, Optional, Pipe, ChangeDetectorRef, Directive, ViewContainerRef, TemplateRef, Input, Renderer2, NgModule } from '@angular/core';
-import { map, auditTime, share, startWith, distinctUntilChanged, shareReplay, tap, takeUntil, filter, pairwise } from 'rxjs/operators';
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Inject, Optional, Pipe, Directive, Input, NgModule } from '@angular/core';
+import { map, share, auditTime, startWith, distinctUntilChanged, shareReplay, tap, takeUntil, filter, pairwise } from 'rxjs/operators';
 import { fromEvent, of, Subscription, Subject, ReplaySubject, combineLatest } from 'rxjs';
 
 var ViewportDataMatchStrategy;
@@ -26,7 +27,7 @@ var ViewportDataMatchStrategy;
  * @returns Returns the matched data value.
  */
 function matchViewportData(dataConfig, sizeType, strategy, sizeTypes, sizeTypeMap) {
-    const matchFn = matchStrategyHandlerMap[strategy];
+    const matchFn = matchStrategyHandlerMap$1[strategy];
     if (!matchFn) {
         throw Error(`matchViewportData: Viewport Data strategy not implemented. Strategy: '${strategy}'`);
     }
@@ -36,7 +37,7 @@ function matchViewportData(dataConfig, sizeType, strategy, sizeTypes, sizeTypeMa
     }
     return dataConfig.default;
 }
-const matchStrategyHandlerMap = {
+const matchStrategyHandlerMap$1 = {
     [ViewportDataMatchStrategy.exact]: matchWithExact,
     [ViewportDataMatchStrategy.larger]: matchWithLargerMatch,
     [ViewportDataMatchStrategy.smaller]: matchWithSmallerMatch,
@@ -132,31 +133,104 @@ const UX_DEFAULT_CONFIG = {
 };
 const UX_CONFIG = new InjectionToken("@ssv/ngx.ux-config");
 
-const WINDOW = new InjectionToken("Window");
-class WindowRef {
-    constructor(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-    window) {
-        this.window = window;
+/**
+ * Utility function to generate rules based on strategies.
+ *
+ * @param dataConfig Data config to generate rules based on.
+ * @param strategy Strategy to use when building rules.
+ * @param sizeTypes Available size types ordered by index type. (Can be obtained from `ViewportService`)
+ * @param sizeTypeMap Available size type map. (Can be obtained from `ViewportService`)
+ * @returns Returns a collection of rules (ordered).
+ */
+function generateViewportRulesRangeFromDataMatcher(dataConfig, strategy, sizeTypes, sizeTypeMap) {
+    const ruleBuilderFn = matchStrategyHandlerMap[strategy];
+    if (!ruleBuilderFn) {
+        throw Error(`generateViewportRulesRangeFromDataMatcher: Viewport Data strategy not implemented. Strategy: '${strategy}'`);
     }
-    /** Window underlying native object. */
-    get native() {
-        return this.window;
+    let dataSizes = [];
+    for (const key in dataConfig) {
+        if (Object.prototype.hasOwnProperty.call(dataConfig, key)) {
+            const data = dataConfig[key];
+            if (data === undefined) {
+                continue;
+            }
+            const size = sizeTypeMap[key];
+            if (size) {
+                dataSizes.push(size);
+            }
+        }
     }
-    /** Determines whether native element is supported or not. Generally `false` when executing in SSR. */
-    get hasNative() {
-        return !!this.native.window;
+    dataSizes = dataSizes.sort(({ type: typeA }, { type: typeB }) => typeA - typeB);
+    const rules = [];
+    if (dataConfig.default) {
+        rules.push({ value: dataConfig.default, min: undefined, max: undefined });
+    }
+    let prevRule;
+    for (let index = 0; index < dataSizes.length; index++) {
+        const prevDataSize = dataSizes[index - 1];
+        const nextDataSize = dataSizes[index + 1];
+        const dataSize = dataSizes[index];
+        const prevSize = sizeTypes[dataSize.type - 1];
+        // const nextSize = sizeTypes[dataSize.type + 1];
+        const data = dataConfig[dataSize.name];
+        const rule = {
+            value: data,
+            min: undefined,
+            max: undefined,
+        };
+        ruleBuilderFn(rule, dataSize, nextDataSize, prevDataSize, prevSize, prevRule, sizeTypes);
+        prevRule = rule;
+        rules.push(rule);
     }
+    return rules;
+}
+const matchStrategyHandlerMap = {
+    [ViewportDataMatchStrategy.exact]: (rule, dataSize, _nextDataSize, _prevDataSize, prevSize) => {
+        rule.max = dataSize.widthThreshold;
+        if (prevSize) {
+            rule.min = prevSize.widthThreshold + 1;
+        }
+    },
+    [ViewportDataMatchStrategy.smaller]: (rule, dataSize, nextDataSize, _prevDataSize, prevSize) => {
+        if (nextDataSize) {
+            rule.max = dataSize.widthThreshold;
+        }
+        if (prevSize) {
+            rule.min = prevSize.widthThreshold + 1;
+        }
+    },
+    [ViewportDataMatchStrategy.larger]: (rule, dataSize, _nextDataSize, prevDataSize) => {
+        if (dataSize) {
+            rule.max = dataSize.widthThreshold;
+        }
+        if (prevDataSize) {
+            rule.min = prevDataSize.widthThreshold + 1;
+        }
+    },
+    [ViewportDataMatchStrategy.closestSmallerFirst]: (rule, dataSize, nextDataSize, _prevDataSize, _prevSize, prevRule, sizeTypes) => {
+        if (nextDataSize) {
+            rule.max = calculateClosestWidthThreshold(nextDataSize, dataSize, sizeTypes, true);
+        }
+        if (prevRule === null || prevRule === void 0 ? void 0 : prevRule.max) {
+            rule.min = prevRule.max + 1;
+        }
+    },
+    [ViewportDataMatchStrategy.closestLargerFirst]: (rule, dataSize, nextDataSize, _prevDataSize, _prevSize, prevRule, sizeTypes) => {
+        if (nextDataSize) {
+            rule.max = calculateClosestWidthThreshold(nextDataSize, dataSize, sizeTypes, false);
+        }
+        if (prevRule === null || prevRule === void 0 ? void 0 : prevRule.max) {
+            rule.min = prevRule.max + 1;
+        }
+    },
+};
+function calculateClosestWidthThreshold(nextDataSize, dataSize, sizeTypes, isSmallerPreferred) {
+    const fn = isSmallerPreferred ? Math.ceil : Math.floor;
+    // get closest between curr and next
+    const diffIndex = fn((nextDataSize.type - dataSize.type - 1) / 2);
+    const diffNextSize = sizeTypes[dataSize.type + diffIndex];
+    return (diffNextSize || dataSize).widthThreshold;
 }
-WindowRef.ɵprov = ɵɵdefineInjectable({ factory: function WindowRef_Factory() { return new WindowRef(ɵɵinject(WINDOW)); }, token: WindowRef, providedIn: "root" });
-WindowRef.decorators = [
-    { type: Injectable, args: [{
-                providedIn: "root",
-            },] }
-];
-WindowRef.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Inject, args: [WINDOW,] }] }
-];
 
 /**
  * The indices of each breakpoint provided based on the `UX_VIEWPORT_DEFAULT_BREAKPOINTS`.
@@ -189,41 +263,6 @@ var DeviceType;
     DeviceType["tablet"] = "tablet";
 })(DeviceType || (DeviceType = {}));
 
-// todo: make this configurable
-/** Viewport size for SSR. */
-const viewportSizeSSR = {
-    [DeviceType.desktop]: {
-        width: 1366,
-        height: 768,
-    },
-    [DeviceType.tablet]: {
-        width: 768,
-        height: 1024,
-    },
-    [DeviceType.mobile]: {
-        width: 414,
-        height: 736,
-    },
-};
-const UX_VIEWPORT_SSR_DEVICE = new InjectionToken("@ssv/ngx.ux-config/viewport/ssr-device");
-class ViewportServerSizeService {
-    constructor(deviceType) {
-        this.deviceType = deviceType;
-    }
-    get() {
-        return viewportSizeSSR[this.deviceType] || viewportSizeSSR[DeviceType.desktop];
-    }
-}
-ViewportServerSizeService.ɵprov = ɵɵdefineInjectable({ factory: function ViewportServerSizeService_Factory() { return new ViewportServerSizeService(ɵɵinject(UX_VIEWPORT_SSR_DEVICE, 8)); }, token: ViewportServerSizeService, providedIn: "root" });
-ViewportServerSizeService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: "root",
-            },] }
-];
-ViewportServerSizeService.ctorParameters = () => [
-    { type: DeviceType, decorators: [{ type: Optional }, { type: Inject, args: [UX_VIEWPORT_SSR_DEVICE,] }] }
-];
-
 function isViewportSizeMatcherExpression(value) {
     if (typeof value !== "object" || !value) {
         return false;
@@ -340,6 +379,77 @@ function generateViewportSizeTypeInfoRefs(breakpointList) {
     }, {}));
 }
 
+const WINDOW = new InjectionToken("Window");
+class WindowRef {
+    constructor(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    window) {
+        this.window = window;
+    }
+    /** Window underlying native object. */
+    get native() {
+        return this.window;
+    }
+    /** Determines whether native element is supported or not. Generally `false` when executing in SSR. */
+    get hasNative() {
+        return !!this.native.window;
+    }
+}
+WindowRef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WindowRef, deps: [{ token: WINDOW }], target: i0.ɵɵFactoryTarget.Injectable });
+WindowRef.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WindowRef, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WindowRef, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [WINDOW]
+                    }] }];
+    } });
+
+// todo: make this configurable
+/** Viewport size for SSR. */
+const viewportSizeSSR = {
+    [DeviceType.desktop]: {
+        width: 1366,
+        height: 768,
+    },
+    [DeviceType.tablet]: {
+        width: 768,
+        height: 1024,
+    },
+    [DeviceType.mobile]: {
+        width: 414,
+        height: 736,
+    },
+};
+const UX_VIEWPORT_SSR_DEVICE = new InjectionToken("@ssv/ngx.ux-config/viewport/ssr-device");
+class ViewportServerSizeService {
+    constructor(deviceType) {
+        this.deviceType = deviceType;
+    }
+    get() {
+        return viewportSizeSSR[this.deviceType] || viewportSizeSSR[DeviceType.desktop];
+    }
+}
+ViewportServerSizeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ViewportServerSizeService, deps: [{ token: UX_VIEWPORT_SSR_DEVICE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+ViewportServerSizeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ViewportServerSizeService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ViewportServerSizeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () {
+        return [{ type: DeviceType, decorators: [{
+                        type: Optional
+                    }, {
+                        type: Inject,
+                        args: [UX_VIEWPORT_SSR_DEVICE]
+                    }] }];
+    } });
+
 class ViewportService {
     constructor(windowRef, viewportServerSize, config) {
         this.windowRef = windowRef;
@@ -347,15 +457,20 @@ class ViewportService {
         this._sizeTypes = generateViewportSizeTypeInfoList(config.viewport.breakpoints);
         this._sizeTypeMap = generateViewportSizeTypeInfoRefs(this._sizeTypes);
         if (windowRef.hasNative) {
-            this.resize$ = fromEvent(window, "resize").pipe(map(() => this.getViewportSize()), auditTime(config.viewport.resizePollingSpeed), share());
+            this.resizeSnap$ = fromEvent(window, "resize").pipe(map(() => this.getViewportSize()), share());
+            this.resize$ = this.resizeSnap$.pipe(auditTime(config.viewport.resizePollingSpeed), share());
         }
         else {
-            this.resize$ = of(viewportServerSize.get());
+            this.resizeSnap$ = this.resize$ = of(viewportServerSize.get());
         }
         const size = this.getViewportSize();
         this._sizeTypeSnapshot = getSizeTypeInfo(size.width, this.sizeTypes);
-        this.size$ = this.resize$.pipe(startWith(size), distinctUntilChanged((a, b) => a.width === b.width && a.height === b.height), shareReplay(1));
-        this.sizeType$ = this.size$.pipe(distinctUntilChanged((a, b) => a.width === b.width), map(x => getSizeTypeInfo(x.width, this.sizeTypes)), distinctUntilChanged(), tap(x => this._sizeTypeSnapshot = x), shareReplay(1));
+        const sizeFn = (obs$) => obs$.pipe(startWith(size), distinctUntilChanged((a, b) => a.width === b.width && a.height === b.height), shareReplay(1));
+        this.sizeSnap$ = sizeFn(this.resizeSnap$);
+        this.size$ = sizeFn(this.resize$);
+        const sizeTypeFn = (obs$) => obs$.pipe(distinctUntilChanged((a, b) => a.width === b.width), map(x => getSizeTypeInfo(x.width, this.sizeTypes)), distinctUntilChanged(), tap(x => this._sizeTypeSnapshot = x), shareReplay(1));
+        this.sizeType$ = sizeTypeFn(this.size$);
+        this.sizeTypeSnap$ = sizeTypeFn(this.sizeSnap$);
     }
     /** Viewport size type snapshot of the last value. (Prefer use `sizeType$` observable when possible.) */
     get sizeTypeSnapshot() { return this._sizeTypeSnapshot; }
@@ -381,116 +496,19 @@ class ViewportService {
         };
     }
 }
-ViewportService.ɵprov = ɵɵdefineInjectable({ factory: function ViewportService_Factory() { return new ViewportService(ɵɵinject(WindowRef), ɵɵinject(ViewportServerSizeService), ɵɵinject(UX_CONFIG)); }, token: ViewportService, providedIn: "root" });
-ViewportService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: "root",
-            },] }
-];
-ViewportService.ctorParameters = () => [
-    { type: WindowRef },
-    { type: ViewportServerSizeService },
-    { type: undefined, decorators: [{ type: Inject, args: [UX_CONFIG,] }] }
-];
-
-/**
- * Utility function to generate rules based on strategies.
- *
- * @param dataConfig Data config to generate rules based on.
- * @param strategy Strategy to use when building rules.
- * @param sizeTypes Available size types ordered by index type. (Can be obtained from `ViewportService`)
- * @param sizeTypeMap Available size type map. (Can be obtained from `ViewportService`)
- * @returns Returns a collection of rules (ordered).
- */
-function generateViewportRulesRangeFromDataMatcher(dataConfig, strategy, sizeTypes, sizeTypeMap) {
-    const ruleBuilderFn = matchStrategyHandlerMap$1[strategy];
-    if (!ruleBuilderFn) {
-        throw Error(`generateViewportRulesRangeFromDataMatcher: Viewport Data strategy not implemented. Strategy: '${strategy}'`);
-    }
-    let dataSizes = [];
-    for (const key in dataConfig) {
-        if (Object.prototype.hasOwnProperty.call(dataConfig, key)) {
-            const data = dataConfig[key];
-            if (data === undefined) {
-                continue;
-            }
-            const size = sizeTypeMap[key];
-            if (size) {
-                dataSizes.push(size);
-            }
-        }
-    }
-    dataSizes = dataSizes.sort(({ type: typeA }, { type: typeB }) => typeA - typeB);
-    const rules = [];
-    if (dataConfig.default) {
-        rules.push({ value: dataConfig.default, min: undefined, max: undefined });
-    }
-    let prevRule;
-    for (let index = 0; index < dataSizes.length; index++) {
-        const prevDataSize = dataSizes[index - 1];
-        const nextDataSize = dataSizes[index + 1];
-        const dataSize = dataSizes[index];
-        const prevSize = sizeTypes[dataSize.type - 1];
-        // const nextSize = sizeTypes[dataSize.type + 1];
-        const data = dataConfig[dataSize.name];
-        const rule = {
-            value: data,
-            min: undefined,
-            max: undefined,
-        };
-        ruleBuilderFn(rule, dataSize, nextDataSize, prevDataSize, prevSize, prevRule, sizeTypes);
-        prevRule = rule;
-        rules.push(rule);
-    }
-    return rules;
-}
-const matchStrategyHandlerMap$1 = {
-    [ViewportDataMatchStrategy.exact]: (rule, dataSize, _nextDataSize, _prevDataSize, prevSize) => {
-        rule.max = dataSize.widthThreshold;
-        if (prevSize) {
-            rule.min = prevSize.widthThreshold + 1;
-        }
-    },
-    [ViewportDataMatchStrategy.smaller]: (rule, dataSize, nextDataSize, _prevDataSize, prevSize) => {
-        if (nextDataSize) {
-            rule.max = dataSize.widthThreshold;
-        }
-        if (prevSize) {
-            rule.min = prevSize.widthThreshold + 1;
-        }
-    },
-    [ViewportDataMatchStrategy.larger]: (rule, dataSize, _nextDataSize, prevDataSize) => {
-        if (dataSize) {
-            rule.max = dataSize.widthThreshold;
-        }
-        if (prevDataSize) {
-            rule.min = prevDataSize.widthThreshold + 1;
-        }
-    },
-    [ViewportDataMatchStrategy.closestSmallerFirst]: (rule, dataSize, nextDataSize, _prevDataSize, _prevSize, prevRule, sizeTypes) => {
-        if (nextDataSize) {
-            rule.max = calculateClosestWidthThreshold(nextDataSize, dataSize, sizeTypes, true);
-        }
-        if (prevRule === null || prevRule === void 0 ? void 0 : prevRule.max) {
-            rule.min = prevRule.max + 1;
-        }
-    },
-    [ViewportDataMatchStrategy.closestLargerFirst]: (rule, dataSize, nextDataSize, _prevDataSize, _prevSize, prevRule, sizeTypes) => {
-        if (nextDataSize) {
-            rule.max = calculateClosestWidthThreshold(nextDataSize, dataSize, sizeTypes, false);
-        }
-        if (prevRule === null || prevRule === void 0 ? void 0 : prevRule.max) {
-            rule.min = prevRule.max + 1;
-        }
-    },
-};
-function calculateClosestWidthThreshold(nextDataSize, dataSize, sizeTypes, isSmallerPreferred) {
-    const fn = isSmallerPreferred ? Math.ceil : Math.floor;
-    // get closest between curr and next
-    const diffIndex = fn((nextDataSize.type - dataSize.type - 1) / 2);
-    const diffNextSize = sizeTypes[dataSize.type + diffIndex];
-    return (diffNextSize || dataSize).widthThreshold;
-}
+ViewportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ViewportService, deps: [{ token: WindowRef }, { token: ViewportServerSizeService }, { token: UX_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+ViewportService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ViewportService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ViewportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () {
+        return [{ type: WindowRef }, { type: ViewportServerSizeService }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [UX_CONFIG]
+                    }] }];
+    } });
 
 class ViewportDataService {
     constructor(viewport, config) {
@@ -502,24 +520,27 @@ class ViewportDataService {
         return matchViewportData(dataConfig, sizeType, strategy, this.viewport.sizeTypes, this.viewport.sizeTypeMap);
     }
     /** Get data for match as observable. */
-    get$(dataConfig, strategy) {
-        return this.viewport.sizeType$.pipe(map(sizeType => this.get(dataConfig, strategy, sizeType)), distinctUntilChanged());
+    get$(dataConfig, strategy, throttle = true) {
+        return (throttle ? this.viewport.sizeType$ : this.viewport.sizeTypeSnap$).pipe(map(sizeType => this.get(dataConfig, strategy, sizeType)), distinctUntilChanged());
     }
     /** Generate rules based on strategies for data. */
     generateRules(dataConfig, strategy = this.config.viewport.defaultDataMatchStrategy) {
         return generateViewportRulesRangeFromDataMatcher(dataConfig, strategy, this.viewport.sizeTypes, this.viewport.sizeTypeMap);
     }
 }
-ViewportDataService.ɵprov = ɵɵdefineInjectable({ factory: function ViewportDataService_Factory() { return new ViewportDataService(ɵɵinject(ViewportService), ɵɵinject(UX_CONFIG)); }, token: ViewportDataService, providedIn: "root" });
-ViewportDataService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: "root",
-            },] }
-];
-ViewportDataService.ctorParameters = () => [
-    { type: ViewportService },
-    { type: undefined, decorators: [{ type: Inject, args: [UX_CONFIG,] }] }
-];
+ViewportDataService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ViewportDataService, deps: [{ token: ViewportService }, { token: UX_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+ViewportDataService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ViewportDataService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ViewportDataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () {
+        return [{ type: ViewportService }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [UX_CONFIG]
+                    }] }];
+    } });
 
 /* eslint-disable @angular-eslint/no-pipe-impure */
 class ViewportDataPipe {
@@ -548,16 +569,15 @@ class ViewportDataPipe {
         this.data$$.unsubscribe();
     }
 }
-ViewportDataPipe.decorators = [
-    { type: Pipe, args: [{
-                name: "ssvViewportData",
-                pure: false
-            },] }
-];
-ViewportDataPipe.ctorParameters = () => [
-    { type: ViewportDataService },
-    { type: ChangeDetectorRef }
-];
+ViewportDataPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ViewportDataPipe, deps: [{ token: ViewportDataService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Pipe });
+ViewportDataPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: ViewportDataPipe, name: "ssvViewportData", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ViewportDataPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "ssvViewportData",
+                    pure: false
+                }]
+        }], ctorParameters: function () { return [{ type: ViewportDataService }, { type: i0.ChangeDetectorRef }]; } });
 
 const NAME_CAMEL = "ssvViewportMatcherVar";
 class SsvViewportMatcherVarContext {
@@ -604,19 +624,17 @@ class SsvViewportMatcherVarDirective {
         this._viewRef = this.viewContainer.createEmbeddedView(this.templateRef, this._context);
     }
 }
-SsvViewportMatcherVarDirective.decorators = [
-    { type: Directive, args: [{
-                selector: `[${NAME_CAMEL}]`,
-            },] }
-];
-SsvViewportMatcherVarDirective.ctorParameters = () => [
-    { type: ViewportService },
-    { type: ViewContainerRef },
-    { type: TemplateRef }
-];
-SsvViewportMatcherVarDirective.propDecorators = {
-    condition: [{ type: Input, args: [`${NAME_CAMEL}When`,] }]
-};
+SsvViewportMatcherVarDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SsvViewportMatcherVarDirective, deps: [{ token: ViewportService }, { token: i0.ViewContainerRef }, { token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+SsvViewportMatcherVarDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: SsvViewportMatcherVarDirective, selector: "[ssvViewportMatcherVar]", inputs: { condition: ["ssvViewportMatcherVarWhen", "condition"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SsvViewportMatcherVarDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `[${NAME_CAMEL}]`,
+                }]
+        }], ctorParameters: function () { return [{ type: ViewportService }, { type: i0.ViewContainerRef }, { type: i0.TemplateRef }]; }, propDecorators: { condition: [{
+                type: Input,
+                args: [`${NAME_CAMEL}When`]
+            }] } });
 
 class SsvViewportMatcherContext {
     constructor() {
@@ -728,24 +746,21 @@ class SsvViewportMatcherDirective {
         }
     }
 }
-SsvViewportMatcherDirective.decorators = [
-    { type: Directive, args: [{
-                selector: "[ssvViewportMatcher]",
-                exportAs: "ssvViewportMatcher",
-            },] }
-];
-SsvViewportMatcherDirective.ctorParameters = () => [
-    { type: ViewportService },
-    { type: Renderer2 },
-    { type: ViewContainerRef },
-    { type: ChangeDetectorRef },
-    { type: TemplateRef }
-];
-SsvViewportMatcherDirective.propDecorators = {
-    ssvViewportMatcher: [{ type: Input }],
-    ssvViewportMatcherExclude: [{ type: Input }],
-    ssvViewportMatcherElse: [{ type: Input }]
-};
+SsvViewportMatcherDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SsvViewportMatcherDirective, deps: [{ token: ViewportService }, { token: i0.Renderer2 }, { token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }, { token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+SsvViewportMatcherDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: SsvViewportMatcherDirective, selector: "[ssvViewportMatcher]", inputs: { ssvViewportMatcher: "ssvViewportMatcher", ssvViewportMatcherExclude: "ssvViewportMatcherExclude", ssvViewportMatcherElse: "ssvViewportMatcherElse" }, exportAs: ["ssvViewportMatcher"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SsvViewportMatcherDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[ssvViewportMatcher]",
+                    exportAs: "ssvViewportMatcher",
+                }]
+        }], ctorParameters: function () { return [{ type: ViewportService }, { type: i0.Renderer2 }, { type: i0.ViewContainerRef }, { type: i0.ChangeDetectorRef }, { type: i0.TemplateRef }]; }, propDecorators: { ssvViewportMatcher: [{
+                type: Input
+            }], ssvViewportMatcherExclude: [{
+                type: Input
+            }], ssvViewportMatcherElse: [{
+                type: Input
+            }] } });
 
 /** @internal */
 const MODULE_CONFIG_DATA = new InjectionToken("@ssv/ngx.ux/configData");
@@ -765,16 +780,27 @@ class SsvUxModule {
         };
     }
 }
-SsvUxModule.decorators = [
-    { type: NgModule, args: [{
-                declarations: [components],
-                providers: [
-                    { provide: UX_CONFIG, useFactory: _moduleConfigFactory, deps: [[MODULE_CONFIG_DATA, new Optional()]] },
-                    { provide: WINDOW, useFactory: _window },
-                ],
-                exports: [...components],
-            },] }
-];
+SsvUxModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SsvUxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SsvUxModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: SsvUxModule, declarations: [SsvViewportMatcherDirective,
+        SsvViewportMatcherVarDirective,
+        ViewportDataPipe], exports: [SsvViewportMatcherDirective,
+        SsvViewportMatcherVarDirective,
+        ViewportDataPipe] });
+SsvUxModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SsvUxModule, providers: [
+        { provide: UX_CONFIG, useFactory: _moduleConfigFactory, deps: [[MODULE_CONFIG_DATA, new Optional()]] },
+        { provide: WINDOW, useFactory: _window },
+    ] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SsvUxModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [components],
+                    providers: [
+                        { provide: UX_CONFIG, useFactory: _moduleConfigFactory, deps: [[MODULE_CONFIG_DATA, new Optional()]] },
+                        { provide: WINDOW, useFactory: _window },
+                    ],
+                    exports: [...components],
+                }]
+        }] });
 /** @internal */
 function _moduleConfigFactory(config) {
     if (!config) {
@@ -792,11 +818,11 @@ function _window() {
     return {};
 }
 
-const VERSION = "2.0.0-dev175";
+const VERSION = "0.0.0-PLACEHOLDER";
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ComparisonOperation, DeviceType, MODULE_CONFIG_DATA, SsvUxModule, SsvViewportMatcherContext, SsvViewportMatcherDirective, SsvViewportMatcherVarContext, SsvViewportMatcherVarDirective, UX_CONFIG, UX_DEFAULT_CONFIG, UX_VIEWPORT_DEFAULT_BREAKPOINTS, UX_VIEWPORT_SSR_DEVICE, VERSION, ViewportDataMatchStrategy, ViewportDataPipe, ViewportDataService, ViewportServerSizeService, ViewportService, ViewportSizeType, _moduleConfigFactory, _window, generateViewportSizeType, UX_VIEWPORT_DEFAULT_CONFIG as ɵa, WINDOW as ɵb, WindowRef as ɵc };
-//# sourceMappingURL=ssv-ngx.ux.js.map
+export { ComparisonOperation, DeviceType, MODULE_CONFIG_DATA, SsvUxModule, SsvViewportMatcherContext, SsvViewportMatcherDirective, SsvViewportMatcherVarContext, SsvViewportMatcherVarDirective, UX_CONFIG, UX_DEFAULT_CONFIG, UX_VIEWPORT_DEFAULT_BREAKPOINTS, UX_VIEWPORT_SSR_DEVICE, VERSION, ViewportDataMatchStrategy, ViewportDataPipe, ViewportDataService, ViewportServerSizeService, ViewportService, ViewportSizeType, _moduleConfigFactory, _window, generateViewportSizeType };
+//# sourceMappingURL=ssv-ngx.ux.mjs.map