@w11k/ngx-present/fesm5/w11k-ngx-present.js

Angular based Presentation Tool

import { CommonModule } from '@angular/common';
import { InjectionToken, Injectable, Injector, ɵɵdefineInjectable, ɵɵinject, INJECTOR, Directive, ElementRef, Optional, Input, Pipe, Component, ViewContainerRef, ComponentFactoryResolver, ViewChild, HostListener, ViewEncapsulation, TemplateRef, NgModule, isDevMode } from '@angular/core';
import { MatButtonModule } from '@angular/material/button';
import { MatCardModule } from '@angular/material/card';
import { MatDialog, MatDialogModule } from '@angular/material/dialog';
import { MatIconModule } from '@angular/material/icon';
import { MatListModule } from '@angular/material/list';
import { MatSidenav, MatSidenavModule } from '@angular/material/sidenav';
import { MatSlideToggleModule } from '@angular/material/slide-toggle';
import { MatToolbarModule } from '@angular/material/toolbar';
import { Router, RouterLinkWithHref, ActivatedRoute, RouterModule } from '@angular/router';
import { TyduxModule } from '@w11k/tydux-angular';
import { Title } from '@angular/platform-browser';
import { __spread, __values, __extends, __assign, __read } from 'tslib';
import { Commands, Facade } from '@w11k/tydux';
import { Observable, Subject, combineLatest, ReplaySubject, fromEvent, of, BehaviorSubject } from 'rxjs';
import { untilComponentDestroyed, OnDestroyMixin } from '@w11k/ngx-componentdestroyed';
import { skipNil, skipPropertyNil } from '@w11k/rx-ninja';
import { filter, takeUntil, take, map, withLatestFrom, delay, first, switchMap } from 'rxjs/operators';

/**
 * @fileoverview added by tsickle
 * Generated from: lib/core/utils.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @template T
 * @param {?} list
 * @return {?}
 */
function maxDepth(list) {
    if (list.length === 0) {
        return 0;
    }
    /**
     * @param {?} value
     * @param {?} currentDepth
     * @return {?}
     */
    function recursive(value, currentDepth) {
        return value.reduce((/**
         * @param {?} depth
         * @param {?} val
         * @return {?}
         */
        function (depth, val) {
            if (Array.isArray(val)) {
                /** @type {?} */
                var newDepth = recursive(val, currentDepth + 1);
                return max(newDepth, depth);
            }
            return depth;
        }), currentDepth + 1);
    }
    return recursive(list, 0);
}
/**
 * @param {?} a
 * @param {?} b
 * @param {...?} c
 * @return {?}
 */
function min(a, b) {
    var c = [];
    for (var _i = 2; _i < arguments.length; _i++) {
        c[_i - 2] = arguments[_i];
    }
    /** @type {?} */
    var values = __spread([a, b], c);
    return values.reduce((/**
     * @param {?} x
     * @param {?} y
     * @return {?}
     */
    function (x, y) { return x > y ? y : x; }));
}
/**
 * @param {?} a
 * @param {?} b
 * @param {...?} c
 * @return {?}
 */
function max(a, b) {
    var c = [];
    for (var _i = 2; _i < arguments.length; _i++) {
        c[_i - 2] = arguments[_i];
    }
    /** @type {?} */
    var values = __spread([a, b], c);
    return values.reduce((/**
     * @param {?} x
     * @param {?} y
     * @return {?}
     */
    function (x, y) { return x > y ? x : y; }));
}
/**
 * @template T
 * @param {?} value
 * @param {?=} result
 * @return {?}
 */
function flattenDeep(value, result) {
    var e_1, _a;
    if (result === void 0) { result = []; }
    try {
        for (var value_1 = __values(value), value_1_1 = value_1.next(); !value_1_1.done; value_1_1 = value_1.next()) {
            var element = value_1_1.value;
            if (Array.isArray(element)) {
                flattenDeep(element, result);
            }
            else {
                result.push(element);
            }
        }
    }
    catch (e_1_1) { e_1 = { error: e_1_1 }; }
    finally {
        try {
            if (value_1_1 && !value_1_1.done && (_a = value_1.return)) _a.call(value_1);
        }
        finally { if (e_1) throw e_1.error; }
    }
    return result;
}
/**
 * @template T, U
 * @param {?} level0
 * @param {?} mapper
 * @return {?}
 */
function mapDeep(level0, mapper) {
    return level0.map((/**
     * @param {?} level1
     * @return {?}
     */
    function (level1) {
        if (Array.isArray(level1)) {
            return mapDeep(level1, mapper);
        }
        else {
            return mapper(level1);
        }
    }));
}
/**
 * @template T
 * @param {?} list
 * @param {?} predicate
 * @return {?}
 */
function filterDeep(list, predicate) {
    /** @type {?} */
    var filtered = [];
    list.forEach((/**
     * @param {?} entry
     * @return {?}
     */
    function (entry) {
        if (Array.isArray(entry)) {
            /** @type {?} */
            var nestedFiltered = filterDeep(entry, predicate);
            if (nestedFiltered.length > 0) {
                filtered.push(nestedFiltered);
            }
        }
        else if (predicate(entry)) {
            filtered.push(entry);
        }
    }));
    return filtered;
}
/**
 * @template S1, S2
 * @param {?} s1
 * @param {...?} sources
 * @return {?}
 */
function mergeDeep(s1) {
    var e_2, _a, e_3, _b;
    var sources = [];
    for (var _i = 1; _i < arguments.length; _i++) {
        sources[_i - 1] = arguments[_i];
    }
    /** @type {?} */
    var target = {};
    /** @type {?} */
    var s1AndSources = __spread([s1], sources);
    try {
        for (var s1AndSources_1 = __values(s1AndSources), s1AndSources_1_1 = s1AndSources_1.next(); !s1AndSources_1_1.done; s1AndSources_1_1 = s1AndSources_1.next()) {
            var source = s1AndSources_1_1.value;
            if (source === undefined) {
                continue;
            }
            /** @type {?} */
            var keys = Object.keys(source);
            try {
                for (var keys_1 = (e_3 = void 0, __values(keys)), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
                    var key = keys_1_1.value;
                    /** @type {?} */
                    var sourceVal = source[key];
                    /** @type {?} */
                    var targetVal = target[key];
                    /** @type {?} */
                    var targetIsObj = typeof targetVal === 'object' && Array.isArray(targetVal) === false;
                    /** @type {?} */
                    var sourceIsObj = typeof sourceVal === 'object' && Array.isArray(sourceVal) === false;
                    if (targetIsObj && sourceIsObj) {
                        /** @type {?} */
                        var merged = mergeDeep(targetVal, sourceVal);
                        target[key] = merged;
                    }
                    else if (source.hasOwnProperty(key)) {
                        target[key] = sourceVal;
                    }
                }
            }
            catch (e_3_1) { e_3 = { error: e_3_1 }; }
            finally {
                try {
                    if (keys_1_1 && !keys_1_1.done && (_b = keys_1.return)) _b.call(keys_1);
                }
                finally { if (e_3) throw e_3.error; }
            }
        }
    }
    catch (e_2_1) { e_2 = { error: e_2_1 }; }
    finally {
        try {
            if (s1AndSources_1_1 && !s1AndSources_1_1.done && (_a = s1AndSources_1.return)) _a.call(s1AndSources_1);
        }
        finally { if (e_2) throw e_2.error; }
    }
    return target;
}
/**
 * @template T
 * @param {?} list
 * @return {?}
 */
function flattenDelayedWithAnimationFrame(list) {
    /** @type {?} */
    var flatList = flattenDeep(list);
    /** @type {?} */
    var observable = new Observable((/**
     * @param {?} subscriber
     * @return {?}
     */
    function (subscriber) {
        /** @type {?} */
        var k = 5;
        /** @type {?} */
        var i = k;
        /** @type {?} */
        var next = (/**
         * @return {?}
         */
        function () {
            subscriber.next(flatList.slice(0, i));
            i = i + k;
            if (i > flatList.length) {
                cancelAnimationFrame(frame);
                subscriber.complete();
            }
            else {
                frame = requestAnimationFrame(next);
            }
        });
        /** @type {?} */
        var frame = requestAnimationFrame(next);
    }));
    return observable;
}
/**
 * @template T
 * @param {?} list
 * @param {?} depth
 * @return {?}
 */
function limitDepth(list, depth) {
    if (depth === undefined || depth < 0) {
        return list;
    }
    return recursive(list, depth);
    /**
     * @param {?} value
     * @param {?} depth_
     * @return {?}
     */
    function recursive(value, depth_) {
        if (depth_ === 0) {
            return [];
        }
        return value
            .map((/**
         * @param {?} x
         * @return {?}
         */
        function (x) {
            if (Array.isArray(x)) {
                return recursive(x, depth_ - 1);
            }
            return x;
        }))
            .filter((/**
         * @param {?} x
         * @return {?}
         */
        function (x) { return (Array.isArray(x) && x.length === 0) === false; }));
    }
}

/**
 * @fileoverview added by tsickle
 * Generated from: lib/core/presentation.types.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var Slide = /** @class */ (function () {
    function Slide(component, coordinates, index) {
        this.component = component;
        this.coordinates = coordinates;
        this.index = index;
    }
    return Slide;
}());
if (false) {
    /** @type {?} */
    Slide.prototype.component;
    /** @type {?} */
    Slide.prototype.coordinates;
    /** @type {?} */
    Slide.prototype.index;
}
/** @type {?} */
var ngxPresentDefaultConfig = {
    sidebar: {
        tableOfContent: {
            enabled: true,
            showCoordinates: (/** @type {?} */ (undefined)),
            separator: (/** @type {?} */ (undefined)),
            depth: (/** @type {?} */ (undefined))
        }
    },
    tableOfContent: {
        showCoordinates: false,
        separator: ')',
        depth: (/** @type {?} */ (undefined)),
    },
    coordinates: {
        separator: '.'
    },
    title: {
        separator: ' / '
    },
    navigation: {
        overview: {
            component: (/** @type {?} */ (undefined))
        }
    },
    presenter: {
        preview1: {
            move: 1,
            coordinatesToKeep: (/** @type {?} */ (undefined))
        },
        preview2: {
            move: 2,
            coordinatesToKeep: (/** @type {?} */ (undefined))
        }
    },
    code: {
        theme: (/** @type {?} */ ('dark'))
    }
};
var PresentationState = /** @class */ (function () {
    function PresentationState() {
        this.config = ngxPresentDefaultConfig;
        this.slides = [];
        this.sideBar = {
            open: false,
            expert: false,
            settings: false
        };
        /** @type {?} */
        var id = Math.random().toString(36).substr(2, 9);
        /** @type {?} */
        var chunks = id.match(/.{1,3}/g);
        if (!chunks) {
            throw new Error("ID generation failed. Couldn't generate chunks from random string");
        }
        this.id = chunks.join('-');
    }
    return PresentationState;
}());
if (false) {
    /** @type {?} */
    PresentationState.prototype.id;
    /** @type {?} */
    PresentationState.prototype.config;
    /** @type {?} */
    PresentationState.prototype.slides;
    /** @type {?} */
    PresentationState.prototype.sideBar;
}
var PresentationCommands = /** @class */ (function (_super) {
    __extends(PresentationCommands, _super);
    function PresentationCommands() {
        return _super.call(this) || this;
    }
    /**
     * @param {?} slides
     * @return {?}
     */
    PresentationCommands.prototype.setSlides = /**
     * @param {?} slides
     * @return {?}
     */
    function (slides) {
        this.state.slides = slides;
    };
    /**
     * @param {?} config
     * @return {?}
     */
    PresentationCommands.prototype.mergeConfig = /**
     * @param {?} config
     * @return {?}
     */
    function (config) {
        this.state.config = mergeDeep(this.state.config, config);
    };
    /**
     * @return {?}
     */
    PresentationCommands.prototype.toggleSideBar = /**
     * @return {?}
     */
    function () {
        this.state.sideBar = __assign(__assign({}, this.state.sideBar), { open: !this.state.sideBar.open });
    };
    /**
     * @return {?}
     */
    PresentationCommands.prototype.closeSideBar = /**
     * @return {?}
     */
    function () {
        this.state.sideBar = __assign(__assign({}, this.state.sideBar), { open: false });
    };
    /**
     * @return {?}
     */
    PresentationCommands.prototype.openSideBar = /**
     * @return {?}
     */
    function () {
        this.state.sideBar = __assign(__assign({}, this.state.sideBar), { open: true });
    };
    /**
     * @return {?}
     */
    PresentationCommands.prototype.enableSideBarExpertMode = /**
     * @return {?}
     */
    function () {
        this.state.sideBar = __assign(__assign({}, this.state.sideBar), { expert: true, settings: true });
    };
    /**
     * @param {?} id
     * @return {?}
     */
    PresentationCommands.prototype.setId = /**
     * @param {?} id
     * @return {?}
     */
    function (id) {
        this.state.id = id;
    };
    /**
     * @param {?} theme
     * @return {?}
     */
    PresentationCommands.prototype.setCodeTheme = /**
     * @param {?} theme
     * @return {?}
     */
    function (theme) {
        this.state.config = __assign(__assign({}, this.state.config), { code: __assign(__assign({}, this.state.config.code), { theme: theme }) });
    };
    return PresentationCommands;
}(Commands));

/**
 * @fileoverview added by tsickle
 * Generated from: lib/core/presentation.functions.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @param {?} component
 * @param {?} coordinates
 * @param {?} index
 * @return {?}
 */
function componentToSlide(component, coordinates, index) {
    return new Slide(component, coordinates, index);
}
/**
 * @param {?} components
 * @param {?} coordinates
 * @param {?} counter
 * @return {?}
 */
function componentsToSlidesRecursive(components, coordinates, counter) {
    if (Array.isArray(components)) {
        return components.map((/**
         * @param {?} x
         * @param {?} i
         * @return {?}
         */
        function (x, i) {
            /** @type {?} */
            var newCoordinates = coordinates.slice();
            newCoordinates.push(i + 1);
            return componentsToSlidesRecursive(x, newCoordinates, counter);
        }));
    }
    counter.index++;
    return componentToSlide(components, coordinates, counter.index);
}
/**
 * @param {?} slideComponents
 * @return {?}
 */
function componentsToSlideTree(slideComponents) {
    /** @type {?} */
    var counter = {
        index: -1
    };
    return slideComponents.map((/**
     * @param {?} x
     * @param {?} i
     * @return {?}
     */
    function (x, i) { return componentsToSlidesRecursive(x, [i + 1], counter); }));
}

/**
 * @fileoverview added by tsickle
 * Generated from: lib/core/presentation.service.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
var NGX_PRESENT_CONFIG = new InjectionToken('NgxPresentConfig');
/** @type {?} */
var SLIDES = new InjectionToken('SLIDES');
var PresentationService = /** @class */ (function (_super) {
    __extends(PresentationService, _super);
    function PresentationService(injector) {
        var _this = _super.call(this, 'Presentation', new PresentationState(), new PresentationCommands()) || this;
        // make mutate public
        _this.dispatch = _this.commands;
        /** @type {?} */
        var slideComponents = injector.get(SLIDES);
        /** @type {?} */
        var config = injector.get(NGX_PRESENT_CONFIG);
        /** @type {?} */
        var slides = componentsToSlideTree(slideComponents);
        _this.commands.setSlides(slides);
        _this.commands.mergeConfig(config);
        return _this;
    }
    /**
     * @param {?} event
     * @return {?}
     */
    PresentationService.prototype.toggleSideBar = /**
     * @param {?} event
     * @return {?}
     */
    function (event) {
        if (event.altKey) {
            this.commands.enableSideBarExpertMode();
        }
        this.commands.toggleSideBar();
    };
    PresentationService.decorators = [
        { type: Injectable, args: [{
                    providedIn: 'root'
                },] }
    ];
    /** @nocollapse */
    PresentationService.ctorParameters = function () { return [
        { type: Injector }
    ]; };
    /** @nocollapse */ PresentationService.ɵprov = ɵɵdefineInjectable({ factory: function PresentationService_Factory() { return new PresentationService(ɵɵinject(INJECTOR)); }, token: PresentationService, providedIn: "root" });
    return PresentationService;
}(Facade));
if (false) {
    /** @type {?} */
    PresentationService.prototype.dispatch;
}

/**
 * @fileoverview added by tsickle
 * Generated from: lib/core/title.service.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var AdvancedTitleService = /** @class */ (function () {
    function AdvancedTitleService(title, presentation) {
        this.title = title;
        this.presentation = presentation;
        this.original = title.getTitle();
    }
    /**
     * @param {?} newTitle
     * @return {?}
     */
    AdvancedTitleService.prototype.setTitle = /**
     * @param {?} newTitle
     * @return {?}
     */
    function (newTitle) {
        var _this = this;
        /** @type {?} */
        var oldTitle = this.title.getTitle();
        this.title.setTitle(newTitle);
        this.lastReturnedUnset = ((/**
         * @return {?}
         */
        function () {
            /** @type {?} */
            var unset = (/**
             * @return {?}
             */
            function () {
                if (_this.lastReturnedUnset === unset) {
                    _this.title.setTitle(oldTitle);
                }
            });
            return unset;
        }))();
        return this.lastReturnedUnset;
    };
    /**
     * @param {?} prefix
     * @param {?=} separator
     * @return {?}
     */
    AdvancedTitleService.prototype.prefixTitle = /**
     * @param {?} prefix
     * @param {?=} separator
     * @return {?}
     */
    function (prefix, separator) {
        if (separator === void 0) { separator = this.presentation.state.config.title.separator; }
        return this.setTitle(prefix + separator + this.original);
    };
    AdvancedTitleService.decorators = [
        { type: Injectable, args: [{
                    providedIn: 'root'
                },] }
    ];
    /** @nocollapse */
    AdvancedTitleService.ctorParameters = function () { return [
        { type: Title },
        { type: PresentationService }
    ]; };
    /** @nocollapse */ AdvancedTitleService.ɵprov = ɵɵdefineInjectable({ factory: function AdvancedTitleService_Factory() { return new AdvancedTitleService(ɵɵinject(Title), ɵɵinject(PresentationService)); }, token: AdvancedTitleService, providedIn: "root" });
    return AdvancedTitleService;
}());
if (false) {
    /**
     * @type {?}
     * @private
     */
    AdvancedTitleService.prototype.lastReturnedUnset;
    /**
     * @type {?}
     * @private
     */
    AdvancedTitleService.prototype.original;
    /**
     * @type {?}
     * @private
     */
    AdvancedTitleService.prototype.title;
    /**
     * @type {?}
     * @private
     */
    AdvancedTitleService.prototype.presentation;
}

/**
 * @fileoverview added by tsickle
 * Generated from: lib/core/page-title.directive.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var PageTitleDirective = /** @class */ (function () {
    function PageTitleDirective(title, element) {
        this.title = title;
        this.element = element;
    }
    /**
     * @return {?}
     */
    PageTitleDirective.prototype.ngAfterViewInit = /**
     * @return {?}
     */
    function () {
        /** @type {?} */
        var pageTitle = this.element.nativeElement.innerText;
        this.unsetTitle = this.title.prefixTitle(pageTitle);
        this.element.nativeElement.hidden = true;
    };
    /**
     * @return {?}
     */
    PageTitleDirective.prototype.ngOnDestroy = /**
     * @return {?}
     */
    function () {
        if (this.unsetTitle) {
            this.unsetTitle();
        }
    };
    PageTitleDirective.decorators = [
        { type: Directive, args: [{
                    selector: '[ngxPresentPageTitle]'
                },] }
    ];
    /** @nocollapse */
    PageTitleDirective.ctorParameters = function () { return [
        { type: AdvancedTitleService },
        { type: ElementRef }
    ]; };
    return PageTitleDirective;
}());
if (false) {
    /** @type {?} */
    PageTitleDirective.prototype.unsetTitle;
    /**
     * @type {?}
     * @private
     */
    PageTitleDirective.prototype.title;
    /**
     * @type {?}
     * @private
     */
    PageTitleDirective.prototype.element;
}

/**
 * @fileoverview added by tsickle
 * Generated from: lib/core/event.service.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @param {?} event
 * @return {?}
 */
function nonNavigationEvent(event) {
    return noModifierPressed(event) && isNotEditable(event);
}
/**
 * @param {?} event
 * @return {?}
 */
function isNotEditable(event) {
    /** @type {?} */
    var srcElement = event.srcElement;
    if (srcElement instanceof HTMLElement) {
        /** @type {?} */
        var tagName = srcElement.tagName;
        if (tagName === 'INPUT' || tagName === 'TEXTAREA' || srcElement.isContentEditable) {
            return false;
        }
    }
    return true;
}
/**
 * @param {?} event
 * @return {?}
 */
function noModifierPressed(event) {
    if (event.altKey || event.ctrlKey || event.shiftKey || event.metaKey) {
        return false;
    }
    return true;
}
/**
 * @abstract
 */
var  /**
 * @abstract
 */
KeyboardEventProcessor = /** @class */ (function () {
    function KeyboardEventProcessor() {
    }
    return KeyboardEventProcessor;
}());
if (false) {
    /**
     * @abstract
     * @param {?} events$
     * @return {?}
     */
    KeyboardEventProcessor.prototype.init = function (events$) { };
}
var ToggleSideNav = /** @class */ (function () {
    function ToggleSideNav(service) {
        this.service = service;
    }
    /**
     * @param {?} events$
     * @return {?}
     */
    ToggleSideNav.prototype.init = /**
     * @param {?} events$
     * @return {?}
     */
    function (events$) {
        var _this = this;
        events$
            .pipe(filter(isNotEditable), filter((/**
         * @param {?} event
         * @return {?}
         */
        function (event) { return !(event.ctrlKey || event.metaKey || event.shiftKey); })), 
        // letter m
        filter((/**
         * @param {?} event
         * @return {?}
         */
        function (event) { return event.keyCode === 77; })))
            .subscribe((/**
         * @param {?} event
         * @return {?}
         */
        function (event) {
            event.preventDefault();
            _this.service.toggleSideBar(event);
        }));
    };
    ToggleSideNav.decorators = [
        { type: Injectable }
    ];
    /** @nocollapse */
    ToggleSideNav.ctorParameters = function () { return [
        { type: PresentationService }
    ]; };
    return ToggleSideNav;
}());
if (false) {
    /**
     * @type {?}
     * @private
     */
    ToggleSideNav.prototype.service;
}
/** @type {?} */
var KEYBOARD_EVENT_PROCESSOR_TOKEN = new InjectionToken('KEYBOARD_EVENT_PROCESSORS');
var EventService = /** @class */ (function () {
    function EventService(injector) {
        var e_1, _a;
        this.keyboardEvents$ = new Subject();
        /** @type {?} */
        var keyboardEventProcessors = injector.get(KEYBOARD_EVENT_PROCESSOR_TOKEN);
        try {
            for (var keyboardEventProcessors_1 = __values(keyboardEventProcessors), keyboardEventProcessors_1_1 = keyboardEventProcessors_1.next(); !keyboardEventProcessors_1_1.done; keyboardEventProcessors_1_1 = keyboardEventProcessors_1.next()) {
                var processor = keyboardEventProcessors_1_1.value;
                processor.init(this.keyboardEvents$);
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (keyboardEventProcessors_1_1 && !keyboardEventProcessors_1_1.done && (_a = keyboardEventProcessors_1.return)) _a.call(keyboardEventProcessors_1);
            }
            finally { if (e_1) throw e_1.error; }
        }
    }
    /**
     * @param {?} event
     * @return {?}
     */
    EventService.prototype.processKeyboardEvent = /**
     * @param {?} event
     * @return {?}
     */
    function (event) {
        // console.debug('EventService: emit keyboard event');
        this.keyboardEvents$.next(event);
    };
    EventService.decorators = [
        { type: Injectable, args: [{
                    providedIn: 'root'
                },] }
    ];
    /** @nocollapse */
    EventService.ctorParameters = function () { return [
        { type: Injector }
    ]; };
    /** @nocollapse */ EventService.ɵprov = ɵɵdefineInjectable({ factory: function EventService_Factory() { return new EventService(ɵɵinject(INJECTOR)); }, token: EventService, providedIn: "root" });
    return EventService;
}());
if (false) {
    /**
     * @type {?}
     * @private
     */
    EventService.prototype.keyboardEvents$;
}

/**
 * @fileoverview added by tsickle
 * Generated from: lib/theming/table-of-content.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
var tableOfContentMetadataKey = Symbol('TableOfContentEntry');
/**
 * @record
 */
function DecoratorMetadata() { }
if (false) {
    /** @type {?} */
    DecoratorMetadata.prototype.linkName;
}
// Decorator
/**
 * @param {?} config
 * @return {?}
 */
function TableOfContentEntry(config) {
    return (/**
     * @param {?} constructor
     * @return {?}
     */
    function (constructor) {
        // TODO: get rid of cast to any, include proper Reflect typings
        ((/** @type {?} */ (Reflect))).defineMetadata(tableOfContentMetadataKey, config, constructor);
    });
}
/**
 * @param {?} slide
 * @return {?}
 */
function tableOfContentMetadata(slide) {
    /** @type {?} */
    var decoratorMetadata = ((/** @type {?} */ (Reflect))).getMetadata(tableOfContentMetadataKey, slide.component);
    return decoratorMetadata;
}
/**
 * @param {?} slides
 * @return {?}
 */
function tableOfContentSlides(slides) {
    return slides.filter((/**
     * @param {?} slide
     * @return {?}
     */
    function (slide) { return tableOfContentMetadata(slide) !== undefined; }));
}

/**
 * @fileoverview added by tsickle
 * Generated from: lib/slide-by-slide/slide-by-slide.functions.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @param {?} slides
 * @param {?} currentSlide
 * @param {?} move
 * @param {?} coordinatesToKeep
 * @param {?} coordinatesMaxDepth
 * @return {?}
 */
function calculateCoordinates(slides, currentSlide, move, coordinatesToKeep, coordinatesMaxDepth) {
    if (move === 0) {
        return currentSlide;
    }
    if (coordinatesToKeep === undefined) {
        return slides[currentSlide.index + move];
    }
    /** @type {?} */
    var currentCoordinates = currentSlide.coordinates;
    /** @type {?} */
    var coordinatesToKeepAbs = coordinatesToKeepAbsolute(currentCoordinates, coordinatesToKeep);
    /** @type {?} */
    var newCoordinates = currentCoordinates.slice(0, coordinatesToKeepAbs);
    if (move > 0 && coordinatesToKeepAbs < currentCoordinates.length) {
        newCoordinates.push(currentCoordinates[coordinatesToKeepAbs] + move);
    }
    else if (move > 0) {
        newCoordinates.push(move);
    }
    else if (move < 0 && currentCoordinates[coordinatesToKeepAbs + 1] !== undefined && currentCoordinates[coordinatesToKeepAbs + 1] > 1) {
        newCoordinates.push(currentCoordinates[coordinatesToKeepAbs] + move + 1);
    }
    else if (move < 0 && coordinatesToKeepAbs < currentCoordinates.length) {
        newCoordinates.push(max(1, currentCoordinates[coordinatesToKeepAbs] + move));
    }
    else if (move < 0) {
        newCoordinates.push(1);
    }
    if (move < 0) {
        while (newCoordinates.length <= coordinatesMaxDepth) {
            newCoordinates.push(1);
        }
    }
    /** @type {?} */
    var arrayToSearchIn;
    if (move >= 0) {
        arrayToSearchIn = slides.slice(currentSlide.index + 1);
    }
    else {
        arrayToSearchIn = slides.slice(0, currentSlide.index).reverse();
    }
    /** @type {?} */
    var nextSlide = arrayToSearchIn.find((/**
     * @param {?} slide
     * @return {?}
     */
    function (slide) {
        /** @type {?} */
        var compared = compareCoordinates(slide.coordinates, newCoordinates);
        if (move < 0) {
            return compared <= 0;
        }
        else {
            return compared >= 0;
        }
    }));
    return nextSlide;
}
/**
 * @param {?} coordinates
 * @param {?} coordinatesToKeepRelative
 * @return {?}
 */
function coordinatesToKeepAbsolute(coordinates, coordinatesToKeepRelative) {
    if (coordinatesToKeepRelative >= 0) {
        return min(coordinatesToKeepRelative, coordinates.length);
    }
    return max(coordinates.length + coordinatesToKeepRelative, 0);
}
/** @type {?} */
var routerParamsCoordinatePrefix = 'coordinate-';
/**
 * @param {?} routeParams
 * @return {?}
 */
function routeParamsToCoordinate(routeParams) {
    /** @type {?} */
    var keys = Object.keys(routeParams);
    /** @type {?} */
    var coordinates = keys
        .filter((/**
     * @param {?} key
     * @return {?}
     */
    function (key) { return key.startsWith(routerParamsCoordinatePrefix); }))
        .map((/**
     * @param {?} key
     * @return {?}
     */
    function (key) {
        /** @type {?} */
        var keyNumber = parseInt(key.substr(routerParamsCoordinatePrefix.length), 10);
        return { key: key, keyNumber: keyNumber };
    }))
        .sort((/**
     * @param {?} a
     * @param {?} b
     * @return {?}
     */
    function (a, b) { return compareNumber(a.keyNumber, b.keyNumber); }))
        .map((/**
     * @param {?} key
     * @return {?}
     */
    function (key) { return parseInt(routeParams[key.key], 10); }));
    return coordinates;
}
/**
 * @param {?} a
 * @param {?} b
 * @return {?}
 */
function compareNumber(a, b) {
    if (a !== undefined && b === undefined) {
        return 1;
    }
    if (a === undefined && b !== undefined) {
        return -1;
    }
    if (a === undefined && b === undefined) {
        return 0;
    }
    if (a !== undefined && b !== undefined && a > b) {
        return 1;
    }
    if (a !== undefined && b !== undefined && a < b) {
        return -1;
    }
    return 0;
}
/**
 * @param {?} c1
 * @param {?} c2
 * @return {?}
 */
function equalCoordinates(c1, c2) {
    return compareCoordinates(c1, c2) === 0;
}
/**
 * @param {?} c1
 * @param {?} c2
 * @return {?}
 */
function compareCoordinates(c1, c2) {
    if (c1 === c2) {
        return 0;
    }
    if (c1 === null || c1 === undefined) {
        return -1;
    }
    if (c2 === null || c2 === undefined) {
        return 1;
    }
    /** @type {?} */
    var maxLength = max(c1.length, c2.length);
    for (var i = 0; i < maxLength; i++) {
        /** @type {?} */
        var c1i = c1[i];
        /** @type {?} */
        var c2i = c2[i];
        /** @type {?} */
        var iResult = compareNumber(c1i, c2i);
        if (iResult !== 0) {
            return iResult;
        }
    }
    return 0;
}
/**
 * @param {?} slides
 * @param {?} coordinates
 * @return {?}
 */
function isValidCoordinate(slides, coordinates) {
    var e_1, _a;
    if (coordinates.length === 0) {
        return false;
    }
    /** @type {?} */
    var current = slides;
    try {
        for (var coordinates_1 = __values(coordinates), coordinates_1_1 = coordinates_1.next(); !coordinates_1_1.done; coordinates_1_1 = coordinates_1.next()) {
            var coordinate = coordinates_1_1.value;
            /** @type {?} */
            var tooLow = coordinate < 1;
            /** @type {?} */
            var tooHigh = Array.isArray(current) && coordinate - 1 >= current.length;
            if (tooLow || tooHigh) {
                return false;
            }
            /** @type {?} */
            var next = current[coordinate - 1];
            if (Array.isArray(next)) {
                current = next;
            }
            else {
                current = [];
            }
        }
    }
    catch (e_1_1) { e_1 = { error: e_1_1 }; }
    finally {
        try {
            if (coordinates_1_1 && !coordinates_1_1.done && (_a = coordinates_1.return)) _a.call(coordinates_1);
        }
        finally { if (e_1) throw e_1.error; }
    }
    return true;
}
/**
 * @param {?} coordinates
 * @param {?} separator
 * @param {?=} length
 * @return {?}
 */
function coordinatesToString(coordinates, separator, length) {
    return coordinates.slice(0, length).join(separator);
}
/**
 * @param {?} slides
 * @return {?}
 */
function coordinateToSlideMap(slides) {
    var e_2, _a;
    /** @type {?} */
    var map = {};
    try {
        for (var slides_1 = __values(slides), slides_1_1 = slides_1.next(); !slides_1_1.done; slides_1_1 = slides_1.next()) {
            var slide = slides_1_1.value;
            /** @type {?} */
            var index = coordinatesToString(slide.coordinates, '.');
            map[index] = slide;
        }
    }
    catch (e_2_1) { e_2 = { error: e_2_1 }; }
    finally {
        try {
            if (slides_1_1 && !slides_1_1.done && (_a = slides_1.return)) _a.call(slides_1);
        }
        finally { if (e_2) throw e_2.error; }
    }
    return map;
}

/**
 * @fileoverview added by tsickle
 * Generated from: lib/slide-by-slide/slide-by-slide.service.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var SlideBySlideState = /** @class */ (function () {
    function SlideBySlideState() {
        this.coordinatesMaxDepth = 0;
        this.slides = [];
        this.slideMap = {};
    }
    return SlideBySlideState;
}());
if (false) {
    /** @type {?} */
    SlideBySlideState.prototype.coordinatesMaxDepth;
    /** @type {?} */
    SlideBySlideState.prototype.slides;
    /** @type {?} */
    SlideBySlideState.prototype.slideMap;
    /** @type {?} */
    SlideBySlideState.prototype.currentSlide;
    /** @type {?} */
    SlideBySlideState.prototype.currentMode;
}
var SlideBySlideMutator = /** @class */ (function (_super) {
    __extends(SlideBySlideMutator, _super);
    function SlideBySlideMutator() {
        return _super.call(this) || this;
    }
    /**
     * @param {?} slide
     * @return {?}
     */
    SlideBySlideMutator.prototype.setCurrentSlide = /**
     * @param {?} slide
     * @return {?}
     */
    function (slide) {
        this.state.currentSlide = slide;
    };
    /**
     * @param {?} mode
     * @return {?}
     */
    SlideBySlideMutator.prototype.setCurrentMode = /**
     * @param {?} mode
     * @return {?}
     */
    function (mode) {
        this.state.currentMode = mode;
    };
    /**
     * @param {?} slides
     * @return {?}
     */
    SlideBySlideMutator.prototype.setSlides = /**
     * @param {?} slides
     * @return {?}
     */
    function (slides) {
        this.state.coordinatesMaxDepth = maxDepth(slides);
        this.state.slides = flattenDeep(slides);
        this.state.slideMap = coordinateToSlideMap(this.state.slides);
    };
    return SlideBySlideMutator;
}(Commands));
var SlideBySlideService = /** @class */ (function (_super) {
    __extends(SlideBySlideService, _super);
    function SlideBySlideService(injector, presentation, router) {
        var _this = _super.call(this, 'SlideBySlide', new SlideBySlideState(), new SlideBySlideMutator()) || this;
        _this.presentation = presentation;
        _this.router = router;
        _this.onDestroy$ = new Subject();
        _this.presentation.select((/**
         * @param {?} state
         * @return {?}
         */
        function (state) { return state.slides; }))
            .pipe(takeUntil(_this.onDestroy$))
            .subscribe((/**
         * @param {?} slides
         * @return {?}
         */
        function (slides) { return _this.commands.setSlides(slides); }));
        return _this;
    }
    /**
     * @param {?} coordinatesToKeep
     * @param {?=} mode
     * @return {?}
     */
    SlideBySlideService.prototype.navigateToNext = /**
     * @param {?} coordinatesToKeep
     * @param {?=} mode
     * @return {?}
     */
    function (coordinatesToKeep, mode) {
        var _this = this;
        this.nextSlide(coordinatesToKeep)
            .pipe(take(1))
            .subscribe((/**
         * @param {?} slide
         * @return {?}
         */
        function (slide) { return _this.navigateAbsolute(slide, mode); }));
    };
    /**
     * @param {?} coordinatesToKeep
     * @param {?=} mode
     * @return {?}
     */
    SlideBySlideService.prototype.navigateToPrevious = /**
     * @param {?} coordinatesToKeep
     * @param {?=} mode
     * @return {?}
     */
    function (coordinatesToKeep, mode) {
        var _this = this;
        this.previousSlide(coordinatesToKeep)
            .pipe(take(1))
            .subscribe((/**
         * @param {?} slide
         * @return {?}
         */
        function (slide) { return _this.navigateAbsolute(slide, mode); }));
    };
    /**
     * @param {?} coordinatesToKeep
     * @param {?=} prefix
     * @return {?}
     */
    SlideBySlideService.prototype.previousSlide = /**
     * @param {?} coordinatesToKeep
     * @param {?=} prefix
     * @return {?}
     */
    function (coordinatesToKeep, prefix) {
        return this.navigateRelative(-1, coordinatesToKeep);
    };
    /**
     * @param {?} coordinatesToKeep
     * @return {?}
     */
    SlideBySlideService.prototype.nextSlide = /**
     * @param {?} coordinatesToKeep
     * @return {?}
     */
    function (coordinatesToKeep) {
        return this.navigateRelative(1, coordinatesToKeep);
    };
    /**
     * @param {?=} mode
     * @return {?}
     */
    SlideBySlideService.prototype.navigateToNextToc = /**
     * @param {?=} mode
     * @return {?}
     */
    function (mode) {
        var _this = this;
        this.nextToc('forward')
            .pipe(take(1))
            .subscribe((/**
         * @param {?} slide
         * @return {?}
         */
        function (slide) { return _this.navigateAbsolute(slide, mode); }));
    };
    /**
     * @param {?=} mode
     * @return {?}
     */
    SlideBySlideService.prototype.navigateToPreviousToc = /**
     * @param {?=} mode
     * @return {?}
     */
    function (mode) {
        var _this = this;
        this.nextToc('backward')
            .pipe(take(1))
            .subscribe((/**
         * @param {?} slide
         * @return {?}
         */
        function (slide) { return _this.navigateAbsolute(slide, mode); }));
    };
    /**
     * @param {?} direction
     * @return {?}
     */
    SlideBySlideService.prototype.nextToc = /**
     * @param {?} direction
     * @return {?}
     */
    function (direction) {
        /** @type {?} */
        var currentSlide$ = this.select((/**
         * @param {?} state
         * @return {?}
         */
        function (state) { return state.currentSlide; }))
            .pipe(skipNil());
        /** @type {?} */
        var tocSlides$ = this.select((/**
         * @param {?} state
         * @return {?}
         */
        function (state) { return state.slides; }))
            .pipe(skipNil(), filter((/**
         * @param {?} x
         * @return {?}
         */
        function (x) { return x.length !== 0; })), map(tableOfContentSlides));
        return combineLatest(currentSlide$, tocSlides$)
            .pipe(map((/**
         * @param {?} __0
         * @return {?}
         */
        function (_a) {
            var _b = __read(_a, 2), currentSlide = _b[0], tocSlides = _b[1];
            if (direction === 'forward') {
                return tocSlides.find((/**
                 * @param {?} tocSlide
                 * @return {?}
                 */
                function (tocSlide) {
                    return compareCoordinates(tocSlide.coordinates, currentSlide.coordinates) === 1;
                }));
            }
            else {
                return tocSlides.slice().reverse().find((/**
                 * @param {?} tocSlide
                 * @return {?}
                 */
                function (tocSlide) {
                    return compareCoordinates(tocSlide.coordinates, currentSlide.coordinates) === -1;
                }));
            }
        })));
    };
    /**
     * @param {?} move
     * @param {?} coordinatesToKeep
     * @return {?}
     */
    SlideBySlideService.prototype.navigateRelative = /**
     * @param {?} move
     * @param {?} coordinatesToKeep
     * @return {?}
     */
    function (move, coordinatesToKeep) {
        /** @type {?} */
        var currentSlide$ = this.select((/**
         * @param {?} state
         * @return {?}
         */
        function (state) { return state.currentSlide; }))
            .pipe(skipNil());
        /** @type {?} */
        var slides$ = this.select((/**
         * @param {?} state
         * @return {?}
         */
        function (state) { return state.slides; }))
            .pipe(skipNil(), filter((/**
         * @param {?} x
         * @return {?}
         */
        function (x) { return x.length !== 0; })));
        /** @type {?} */
        var depth$ = this.select((/**
         * @param {?} state
         * @return {?}
         */
        function (state) { return state.coordinatesMaxDepth; }))
            .pipe(skipNil());
        return combineLatest(slides$, currentSlide$, depth$)
            .pipe(map((/**
         * @param {?} __0
         * @return {?}
         */
        function (_a) {
            var _b = __read(_a, 3), slides = _b[0], current = _b[1], depth = _b[2];
            return calculateCoordinates(slides, current, move, coordinatesToKeep, depth);
        })));
    };
    /**
     * @param {?} target
     * @param {?=} mode
     * @return {?}
     */
    SlideBySlideService.prototype.navigateAbsolute = /**
     * @param {?} target
     * @param {?=} mode
     * @return {?}
     */
    function (target, mode) {
        /** @type {?} */
        var slide;
        if (target instanceof Slide) {
            slide = target;
        }
        else {
            slide = this.state.slides.find((/**
             * @param {?} x
             * @return {?}
             */
            function (x) { return equalCoordinates(target, x.coordinates); }));
        }
        if (slide === undefined) {
            return;
        }
        /** @type {?} */
        var modeWithFallback;
        if (mode !== undefined) {
            modeWithFallback = mode;
        }
        else if (this.state.currentMode !== undefined) {
            modeWithFallback = this.state.currentMode;
        }
        else {
            modeWithFallback = 'slide';
        }
        /** @type {?} */
        var link = __spread(["/" + modeWithFallback], slide.coordinates);
        return this.router.navigate(link, { queryParamsHandling: 'merge' });
    };
    /**
     * @param {?=} prefix
     * @return {?}
     */
    SlideBySlideService.prototype.navigateToFirst = /**
     * @param {?=} prefix
     * @return {?}
     */
    function (prefix) {
        var _this = this;
        this.firstSlide()
            .pipe(take(1), takeUntil(this.onDestroy$))
            .subscribe((/**
         * @param {?} slide
         * @return {?}
         */
        function (slide) { return _this.navigateAbsolute(slide, prefix); }));
    };
    /**
     * @return {?}
     */
    SlideBySlideService.prototype.firstSlide = /**
     * @return {?}
     */
    function () {
        return this.select((/**
         * @param {?} state
         * @return {?}
         */
        function (state) { return state.slides; }))
            .pipe(skipNil(), filter((/**
         * @param {?} slides
         * @return {?}
         */
        function (slides) { return slides.length > 0; })), map((/**
         * @param {?} slides
         * @return {?}
         */
        function (slides) { return slides[0]; })));
    };
    /**
     * @param {?} coordinates
     * @return {?}
     */
    SlideBySlideService.prototype.isValidCoordinate = /**
     * @param {?} coordinates
     * @return {?}
     */
    function (coordinates) {
        return this.presentation.select((/**
         * @param {?} state
         * @return {?}
         */
        function (state) { return state.slides; }))
            .pipe(skipNil(), filter((/**
         * @param {?} slides
         * @return {?}
         */
        function (slides) { return slides.length > 0; })), map((/**
         * @param {?} slides
         * @return {?}
         */
        function (slides) { return isValidCoordinate(slides, coordinates); })));
    };
    /**
     * @private
     * @param {?} coordinates
     * @return {?}
     */
    SlideBySlideService.prototype.coordinatesToSlide = /**
     * @private
     * @param {?} coordinates
     * @return {?}
     */
    function (coordinates) {
        return this.state.slideMap[coordinates.join('.')];
    };
    /**
     * @param {?} route
     * @return {?}
     */
    SlideBySlideService.prototype.setCurrentModeAndSlide = /**
     * @param {?} route
     * @return {?}
     */
    function (route) {
        /** @type {?} */
        var coordinates = routeParamsToCoordinate(route.params);
        /** @type {?} */
        var mode = (/** @type {?} */ (route.url[0].path));
        /** @type {?} */
        var slide = this.coordinatesToSlide(coordinates);
        this.commands.setCurrentSlide(slide);
        this.commands.setCurrentMode(mode);
    };
    /**
     * @return {?}
     */
    SlideBySlideService.prototype.ngOnDestroy = /**
     * @return {?}
     */
    function () {
        this.onDestroy$.next();
    };
    SlideBySlideService.decorators = [
        { type: Injectable, args: [{
                    providedIn: 'root'
                },] }
    ];
    /** @nocollapse */
    SlideBySlideService.ctorParameters = function () { return [
        { type: Injector },
        { type: PresentationService },
        { type: Router }
    ]; };
    /** @nocollapse */ SlideBySlideService.ɵprov = ɵɵdefineInjectable({ factory: function SlideBySlideService_Factory() { return new SlideBySlideService(ɵɵinject(INJECTOR), ɵɵinject(PresentationService), ɵɵinject(Router)); }, token: SlideBySlideService, providedIn: "root" });
    return SlideBySlideService;
}(Facade));
if (false) {
    /**
     * @type {?}
     * @private
     */
    SlideBySlideService.prototype.onDestroy$;
    /**
     * @type {?}
     * @private
     */
    SlideBySlideService.prototype.presentation;
    /**
     * @type {?}
     * @private
     */
    SlideBySlideService.prototype.router;
}
var NavigateSectionForward = /** @class */ (function () {
    function NavigateSectionForward(service) {
        this.service = service;
    }
    /**
     * @param {?} events$
     * @return {?}
     */
    NavigateSectionForward.prototype.init = /**
     * @param {?} events$
     * @return {?}
     */
    function (events$) {
        var _this = this;
        events$
            .pipe(filter(isNotEditable), 
        // arrow down + alt || arrow right + alt
        filter((/**
         * @param {?} event
         * @return {?}
         */
        function (event) {
            if (event.keyCode === 40 && event.altKey) {
                return true;
            }
            else if (event.keyCode === 39 && event.altKey) {
                return true;
            }
            return false;
        })))
            .subscribe((/**
         * @return {?}
         */
        function () {
            _this.service.navigateToNextToc();
        }));
    };
    NavigateSectionForward.decorators = [
        { type: Injectable }
    ];
    /** @nocollapse */
    NavigateSectionForward.ctorParameters = function () { return [
        { type: SlideBySlideService }
    ]; };
    return NavigateSectionForward;
}());
if (false) {
    /**
     * @type {?}
     * @private
     */
    NavigateSectionForward.prototype.service;
}
var NavigateSlideForward = /** @class */ (function () {
    function NavigateSlideForward(service) {
        this.service = service;
    }
    /**
     * @param {?} events$
     * @return {?}
     */
    NavigateSlideForward.prototype.init = /**
     * @param {?} events$
     * @return {?}
     */
    function (events$) {
        var _this = this;
        events$
            .pipe(filter(nonNavigationEvent), 
        // arrow down, arrow right, or page down
        filter((/**
         * @param {?} event
         * @return {?}
         */
        function (event) { return event.keyCode === 40 || event.keyCo