@gipisistemas/ng-core 1.1.0 → 1.1.2

package/esm5/shared/gipi-components/datepicker/mat-datepicker/datepicker-intl.js

@@ -0,0 +1,52 @@
+import { __decorate } from "tslib";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/** Datepicker data that requires internationalization. */
+var MatDatepickerIntl = /** @class */ (function () {
+    function MatDatepickerIntl() {
+        /**
+         * Stream that emits whenever the labels here are changed. Use this to notify
+         * components if the labels have changed after initialization.
+         */
+        this.changes = new Subject();
+        /** A label for the calendar popup (used by screen readers). */
+        this.calendarLabel = 'Calendar';
+        /** A label for the button used to open the calendar popup (used by screen readers). */
+        this.openCalendarLabel = 'Open calendar';
+        /** A label for the previous month button (used by screen readers). */
+        this.prevMonthLabel = 'Previous month';
+        /** A label for the next month button (used by screen readers). */
+        this.nextMonthLabel = 'Next month';
+        /** A label for the previous year button (used by screen readers). */
+        this.prevYearLabel = 'Previous year';
+        /** A label for the next year button (used by screen readers). */
+        this.nextYearLabel = 'Next year';
+        /** A label for the previous multi-year button (used by screen readers). */
+        this.prevMultiYearLabel = 'Previous 20 years';
+        /** A label for the next multi-year button (used by screen readers). */
+        this.nextMultiYearLabel = 'Next 20 years';
+        /** A label for the 'switch to month view' button (used by screen readers). */
+        this.switchToMonthViewLabel = 'Choose date';
+        /** A label for the 'switch to year view' button (used by screen readers). */
+        this.switchToMultiYearViewLabel = 'Choose month and year';
+    }
+    /** Formats a range of years. */
+    MatDatepickerIntl.prototype.formatYearRange = function (start, end) {
+        return start + " \u2013 " + end;
+    };
+    MatDatepickerIntl.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function MatDatepickerIntl_Factory() { return new MatDatepickerIntl(); }, token: MatDatepickerIntl, providedIn: "root" });
+    MatDatepickerIntl = __decorate([
+        Injectable({ providedIn: 'root' })
+    ], MatDatepickerIntl);
+    return MatDatepickerIntl;
+}());
+export { MatDatepickerIntl };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/shared/gipi-components/datepicker/mat-datepicker/datepicker-toggle.js

@@ -0,0 +1,133 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { __decorate, __metadata, __param } from "tslib";
+import { AfterContentInit, Attribute, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, Directive, Input, OnChanges, OnDestroy, SimpleChanges, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { MatButton } from '@angular/material/button';
+import { merge, of as observableOf, Subscription } from 'rxjs';
+import { MatDatepickerBase } from './datepicker-base';
+import { MatDatepickerIntl } from './datepicker-intl';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+/** Can be used to override the icon of a `matDatepickerToggle`. */
+var MatDatepickerToggleIcon = /** @class */ (function () {
+    function MatDatepickerToggleIcon() {
+    }
+    MatDatepickerToggleIcon = __decorate([
+        Directive({ selector: '[gipiDatepickerToggleIcon]' })
+    ], MatDatepickerToggleIcon);
+    return MatDatepickerToggleIcon;
+}());
+export { MatDatepickerToggleIcon };
+var MatDatepickerToggle = /** @class */ (function () {
+    function MatDatepickerToggle(_intl, _changeDetectorRef, defaultTabIndex) {
+        this._intl = _intl;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._stateChanges = Subscription.EMPTY;
+        var parsedTabIndex = Number(defaultTabIndex);
+        this.tabIndex = (parsedTabIndex || parsedTabIndex === 0) ? parsedTabIndex : null;
+    }
+    Object.defineProperty(MatDatepickerToggle.prototype, "disabled", {
+        /** Whether the toggle button is disabled. */
+        get: function () {
+            if (this._disabled === undefined && this.datepicker) {
+                return this.datepicker.disabled;
+            }
+            return !!this._disabled;
+        },
+        set: function (value) {
+            this._disabled = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MatDatepickerToggle.prototype.ngOnChanges = function (changes) {
+        if (changes['datepicker']) {
+            this._watchStateChanges();
+        }
+    };
+    MatDatepickerToggle.prototype.ngOnDestroy = function () {
+        this._stateChanges.unsubscribe();
+    };
+    MatDatepickerToggle.prototype.ngAfterContentInit = function () {
+        this._watchStateChanges();
+    };
+    MatDatepickerToggle.prototype._open = function (event) {
+        if (this.datepicker && !this.disabled) {
+            this.datepicker.open();
+            event.stopPropagation();
+        }
+    };
+    MatDatepickerToggle.prototype._watchStateChanges = function () {
+        var _this = this;
+        var datepickerStateChanged = this.datepicker ? this.datepicker._stateChanges : observableOf();
+        var inputStateChanged = this.datepicker && this.datepicker._datepickerInput ?
+            this.datepicker._datepickerInput.stateChanges : observableOf();
+        var datepickerToggled = this.datepicker ?
+            merge(this.datepicker.openedStream, this.datepicker.closedStream) :
+            observableOf();
+        this._stateChanges.unsubscribe();
+        this._stateChanges = merge(this._intl.changes, datepickerStateChanged, inputStateChanged, datepickerToggled).subscribe(function () { return _this._changeDetectorRef.markForCheck(); });
+    };
+    MatDatepickerToggle.ctorParameters = function () { return [
+        { type: MatDatepickerIntl },
+        { type: ChangeDetectorRef },
+        { type: String, decorators: [{ type: Attribute, args: ['tabindex',] }] }
+    ]; };
+    __decorate([
+        Input('for'),
+        __metadata("design:type", MatDatepickerBase)
+    ], MatDatepickerToggle.prototype, "datepicker", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], MatDatepickerToggle.prototype, "tabIndex", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], MatDatepickerToggle.prototype, "disabled", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], MatDatepickerToggle.prototype, "disableRipple", void 0);
+    __decorate([
+        ContentChild(MatDatepickerToggleIcon, { static: true }),
+        __metadata("design:type", MatDatepickerToggleIcon)
+    ], MatDatepickerToggle.prototype, "_customIcon", void 0);
+    __decorate([
+        ViewChild('button', { static: true }),
+        __metadata("design:type", MatButton)
+    ], MatDatepickerToggle.prototype, "_button", void 0);
+    MatDatepickerToggle = __decorate([
+        Component({
+            selector: 'gipi-mat-datepicker-toggle',
+            template: "<button #button\n        mat-icon-button\n        type=\"button\"\n        [attr.aria-haspopup]=\"datepicker ? 'dialog' : null\"\n        [attr.aria-label]=\"_intl.openCalendarLabel\"\n        [attr.tabindex]=\"disabled ? -1 : tabIndex\"\n        [disabled]=\"disabled\"\n        [disableRipple]=\"disableRipple\"\n        (click)=\"_open($event)\">\n\n    <svg *ngIf=\"!_customIcon\"\n         class=\"mat-datepicker-toggle-default-icon\"\n         viewBox=\"0 0 24 24\"\n         width=\"24px\"\n         height=\"24px\"\n         fill=\"currentColor\"\n         focusable=\"false\">\n        <path\n              d=\"M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z\" />\n    </svg>\n\n    <ng-content select=\"[gipiMatDatepickerToggleIcon]\"> </ng-content>\n</button>",
+            host: {
+                'class': 'mat-datepicker-toggle',
+                // Always set the tabindex to -1 so that it doesn't overlap with any custom tabindex the
+                // consumer may have provided, while still being able to receive focus.
+                '[attr.tabindex]': 'disabled ? null : -1',
+                '[class.mat-datepicker-toggle-active]': 'datepicker && datepicker.opened',
+                '[class.mat-accent]': 'datepicker && datepicker.color === "accent"',
+                '[class.mat-warn]': 'datepicker && datepicker.color === "warn"',
+                // Used by the test harness to tie this toggle to its datepicker.
+                '[attr.data-mat-calendar]': 'datepicker ? datepicker.id : null',
+                '(focus)': '_button.focus()',
+            },
+            exportAs: 'gipiMatDatepickerToggle',
+            encapsulation: ViewEncapsulation.None,
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            styles: [".mat-form-field-appearance-legacy .mat-form-field-prefix .mat-datepicker-toggle-default-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-datepicker-toggle-default-icon{width:1em}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-datepicker-toggle-default-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-datepicker-toggle-default-icon{display:block;width:1.5em;height:1.5em}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-datepicker-toggle-default-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-datepicker-toggle-default-icon{margin:auto}"]
+        }),
+        __param(2, Attribute('tabindex')),
+        __metadata("design:paramtypes", [MatDatepickerIntl,
+            ChangeDetectorRef, String])
+    ], MatDatepickerToggle);
+    return MatDatepickerToggle;
+}());
+export { MatDatepickerToggle };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker-toggle.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/datepicker-toggle.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { AfterContentInit, Attribute, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, Directive, Input, OnChanges, OnDestroy, SimpleChanges, ViewChild, ViewEncapsulation, } from '@angular/core';\nimport { MatButton } from '@angular/material/button';\nimport { merge, of as observableOf, Subscription } from 'rxjs';\nimport { MatDatepickerBase, MatDatepickerControl } from './datepicker-base';\nimport { MatDatepickerIntl } from './datepicker-intl';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\n\n/** Can be used to override the icon of a `matDatepickerToggle`. */\n@Directive({ selector: '[gipiDatepickerToggleIcon]' })\nexport class MatDatepickerToggleIcon { }\n\n@Component({\n    selector: 'gipi-mat-datepicker-toggle',\n    templateUrl: 'datepicker-toggle.html',\n    styleUrls: ['datepicker-toggle.scss'],\n    host: {\n        'class': 'mat-datepicker-toggle',\n        // Always set the tabindex to -1 so that it doesn't overlap with any custom tabindex the\n        // consumer may have provided, while still being able to receive focus.\n        '[attr.tabindex]': 'disabled ? null : -1',\n        '[class.mat-datepicker-toggle-active]': 'datepicker && datepicker.opened',\n        '[class.mat-accent]': 'datepicker && datepicker.color === \"accent\"',\n        '[class.mat-warn]': 'datepicker && datepicker.color === \"warn\"',\n        // Used by the test harness to tie this toggle to its datepicker.\n        '[attr.data-mat-calendar]': 'datepicker ? datepicker.id : null',\n        '(focus)': '_button.focus()',\n    },\n    exportAs: 'gipiMatDatepickerToggle',\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MatDatepickerToggle<D> implements AfterContentInit, OnChanges, OnDestroy {\n\n    private _stateChanges = Subscription.EMPTY;\n\n    /** Datepicker instance that the button will toggle. */\n    @Input('for') datepicker: MatDatepickerBase<MatDatepickerControl<any>, D>;\n\n    /** Tabindex for the toggle. */\n    @Input() tabIndex: number | null;\n\n    /** Whether the toggle button is disabled. */\n    @Input()\n    get disabled(): boolean {\n        if (this._disabled === undefined && this.datepicker) {\n            return this.datepicker.disabled;\n        }\n\n        return !!this._disabled;\n    }\n    set disabled(value: boolean) {\n        this._disabled = coerceBooleanProperty(value);\n    }\n    private _disabled: boolean;\n\n    /** Whether ripples on the toggle should be disabled. */\n    @Input() disableRipple: boolean;\n\n    /** Custom icon set by the consumer. */\n    @ContentChild(MatDatepickerToggleIcon, { static: true }) _customIcon: MatDatepickerToggleIcon;\n\n    /** Underlying button element. */\n    @ViewChild('button', { static: true }) _button: MatButton;\n\n    constructor(\n        public _intl: MatDatepickerIntl,\n        private _changeDetectorRef: ChangeDetectorRef,\n        @Attribute('tabindex') defaultTabIndex: string\n    ) {\n\n        const parsedTabIndex = Number(defaultTabIndex);\n        this.tabIndex = (parsedTabIndex || parsedTabIndex === 0) ? parsedTabIndex : null;\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes['datepicker']) {\n            this._watchStateChanges();\n        }\n    }\n\n    ngOnDestroy() {\n        this._stateChanges.unsubscribe();\n    }\n\n    ngAfterContentInit() {\n        this._watchStateChanges();\n    }\n\n    _open(event: Event): void {\n        if (this.datepicker && !this.disabled) {\n            this.datepicker.open();\n            event.stopPropagation();\n        }\n    }\n\n    private _watchStateChanges() {\n        const datepickerStateChanged = this.datepicker ? this.datepicker._stateChanges : observableOf();\n        const inputStateChanged = this.datepicker && this.datepicker._datepickerInput ?\n            this.datepicker._datepickerInput.stateChanges : observableOf();\n        const datepickerToggled = this.datepicker ?\n            merge(this.datepicker.openedStream, this.datepicker.closedStream) :\n            observableOf();\n\n        this._stateChanges.unsubscribe();\n        this._stateChanges = merge(\n            this._intl.changes,\n            datepickerStateChanged,\n            inputStateChanged,\n            datepickerToggled\n        ).subscribe(() => this._changeDetectorRef.markForCheck());\n    }\n\n\n}\n"]}

package/esm5/shared/gipi-components/datepicker/mat-datepicker/datepicker.js

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { __decorate, __extends } from "tslib";
+import { ChangeDetectionStrategy, Component, ViewEncapsulation } from '@angular/core';
+import { MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER } from './date-selection-model';
+import { MatDatepickerBase } from './datepicker-base';
+// TODO(mmalerba): We use a component instead of a directive here so the user can use implicit
+// template reference variables (e.g. #d vs #d="matDatepicker"). We can change this to a directive
+// if angular adds support for `exportAs: '$implicit'` on directives.
+/** Component responsible for managing the datepicker popup/dialog. */
+var MatDatepicker = /** @class */ (function (_super) {
+    __extends(MatDatepicker, _super);
+    function MatDatepicker() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MatDatepicker = __decorate([
+        Component({
+            selector: 'gipi-mat-datepicker',
+            template: '',
+            exportAs: 'gipiMatDatepicker',
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            encapsulation: ViewEncapsulation.None,
+            providers: [MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER]
+        })
+    ], MatDatepicker);
+    return MatDatepicker;
+}(MatDatepickerBase));
+export { MatDatepicker };
+//# sourceMappingURL=data:application/json;base64,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