@gipisistemas/ng-core 1.1.0 → 1.1.1

package/esm2015/shared/gipi-components/datepicker/mat-datepicker/date-selection-model.js

@@ -0,0 +1,159 @@
+/**
+ * @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 } from "tslib";
+import { Injectable, Optional, SkipSelf } from '@angular/core';
+import { Subject } from 'rxjs';
+import { DateAdapter } from './shared/adapter/date-adapter';
+/** A class representing a range of dates. */
+export class DateRange {
+    constructor(
+    /** The start date of the range. */
+    start, 
+    /** The end date of the range. */
+    end) {
+        this.start = start;
+        this.end = end;
+    }
+}
+/** A selection model containing a date selection. */
+export class MatDateSelectionModel {
+    constructor(
+    /** The current selection. */
+    selection, _adapter) {
+        this.selection = selection;
+        this._adapter = _adapter;
+        this._selectionChanged = new Subject();
+        /** Emits when the selection has changed. */
+        this.selectionChanged = this._selectionChanged;
+        this.selection = selection;
+    }
+    /**
+     * Updates the current selection in the model.
+     * @param value New selection that should be assigned.
+     * @param source Object that triggered the selection change.
+     */
+    updateSelection(value, source) {
+        this.selection = value;
+        this._selectionChanged.next({ selection: value, source });
+    }
+    ngOnDestroy() {
+        this._selectionChanged.complete();
+    }
+    _isValidDateInstance(date) {
+        return this._adapter.isDateInstance(date) && this._adapter.isValid(date);
+    }
+}
+/**  A selection model that contains a single date. */
+let MatSingleDateSelectionModel = class MatSingleDateSelectionModel extends MatDateSelectionModel {
+    constructor(adapter) {
+        super(null, adapter);
+    }
+    /**
+     * Adds a date to the current selection. In the case of a single date selection, the added date
+     * simply overwrites the previous selection
+     */
+    add(date) {
+        super.updateSelection(date, this);
+    }
+    /** Checks whether the current selection is valid. */
+    isValid() {
+        return this.selection != null && this._isValidDateInstance(this.selection);
+    }
+    /**
+     * Checks whether the current selection is complete. In the case of a single date selection, this
+     * is true if the current selection is not null.
+     */
+    isComplete() {
+        return this.selection != null;
+    }
+};
+MatSingleDateSelectionModel.ctorParameters = () => [
+    { type: DateAdapter }
+];
+MatSingleDateSelectionModel = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DateAdapter])
+], MatSingleDateSelectionModel);
+export { MatSingleDateSelectionModel };
+/**  A selection model that contains a date range. */
+let MatRangeDateSelectionModel = class MatRangeDateSelectionModel extends MatDateSelectionModel {
+    constructor(adapter) {
+        super(new DateRange(null, null), adapter);
+    }
+    /**
+     * Adds a date to the current selection. In the case of a date range selection, the added date
+     * fills in the next `null` value in the range. If both the start and the end already have a date,
+     * the selection is reset so that the given date is the new `start` and the `end` is null.
+     */
+    add(date) {
+        let { start, end } = this.selection;
+        if (start == null) {
+            start = date;
+        }
+        else if (end == null) {
+            end = date;
+        }
+        else {
+            start = date;
+            end = null;
+        }
+        super.updateSelection(new DateRange(start, end), this);
+    }
+    /** Checks whether the current selection is valid. */
+    isValid() {
+        const { start, end } = this.selection;
+        // Empty ranges are valid.
+        if (start == null && end == null) {
+            return true;
+        }
+        // Complete ranges are only valid if both dates are valid and the start is before the end.
+        if (start != null && end != null) {
+            return this._isValidDateInstance(start) && this._isValidDateInstance(end) &&
+                this._adapter.compareDate(start, end) <= 0;
+        }
+        // Partial ranges are valid if the start/end is valid.
+        return (start == null || this._isValidDateInstance(start)) &&
+            (end == null || this._isValidDateInstance(end));
+    }
+    /**
+     * Checks whether the current selection is complete. In the case of a date range selection, this
+     * is true if the current selection has a non-null `start` and `end`.
+     */
+    isComplete() {
+        return this.selection.start != null && this.selection.end != null;
+    }
+};
+MatRangeDateSelectionModel.ctorParameters = () => [
+    { type: DateAdapter }
+];
+MatRangeDateSelectionModel = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DateAdapter])
+], MatRangeDateSelectionModel);
+export { MatRangeDateSelectionModel };
+/** @docs-private */
+export function MAT_SINGLE_DATE_SELECTION_MODEL_FACTORY(parent, adapter) {
+    return parent || new MatSingleDateSelectionModel(adapter);
+}
+/** Used to provide a single selection model to a component. */
+export const MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER = {
+    provide: MatDateSelectionModel,
+    deps: [[new Optional(), new SkipSelf(), MatDateSelectionModel], DateAdapter],
+    useFactory: MAT_SINGLE_DATE_SELECTION_MODEL_FACTORY,
+};
+/** @docs-private */
+export function MAT_RANGE_DATE_SELECTION_MODEL_FACTORY(parent, adapter) {
+    return parent || new MatRangeDateSelectionModel(adapter);
+}
+/** Used to provide a range selection model to a component. */
+export const MAT_RANGE_DATE_SELECTION_MODEL_PROVIDER = {
+    provide: MatDateSelectionModel,
+    deps: [[new Optional(), new SkipSelf(), MatDateSelectionModel], DateAdapter],
+    useFactory: MAT_RANGE_DATE_SELECTION_MODEL_FACTORY,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-selection-model.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/date-selection-model.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 { Directive, FactoryProvider, Injectable, OnDestroy, Optional, SkipSelf } from '@angular/core';\nimport { Observable, Subject } from 'rxjs';\nimport { DateAdapter } from './shared/adapter/date-adapter';\n\n/** A class representing a range of dates. */\nexport class DateRange<D> {\n    /**\n     * Ensures that objects with a `start` and `end` property can't be assigned to a variable that\n     * expects a `DateRange`\n     */\n    // tslint:disable-next-line:no-unused-variable\n    private _disableStructuralEquivalency: never;\n\n    constructor(\n        /** The start date of the range. */\n        readonly start: D | null,\n        /** The end date of the range. */\n        readonly end: D | null,\n    ) { }\n}\n\n/**\n * Conditionally picks the date type, if a DateRange is passed in.\n * @docs-private\n */\nexport type ExtractDateTypeFromSelection<T> = T extends DateRange<infer D> ? D : NonNullable<T>;\n\n/** Event emitted by the date selection model when its selection changes. */\nexport interface DateSelectionModelChange<S> {\n    /** New value for the selection. */\n    selection: S;\n\n    /** Object that triggered the change. */\n    source: unknown;\n}\n\n/** A selection model containing a date selection. */\nexport abstract class MatDateSelectionModel<S, D = any> implements OnDestroy {\n\n    private _selectionChanged = new Subject<DateSelectionModelChange<S>>();\n\n    /** Emits when the selection has changed. */\n    selectionChanged: Observable<DateSelectionModelChange<S>> = this._selectionChanged;\n\n    protected constructor(\n        /** The current selection. */\n        readonly selection: S,\n        protected _adapter: DateAdapter<D>\n    ) {\n        this.selection = selection;\n    }\n\n    /**\n     * Updates the current selection in the model.\n     * @param value New selection that should be assigned.\n     * @param source Object that triggered the selection change.\n     */\n    updateSelection(value: S, source: unknown) {\n        (this as { selection: S }).selection = value;\n        this._selectionChanged.next({ selection: value, source });\n    }\n\n    ngOnDestroy() {\n        this._selectionChanged.complete();\n    }\n\n    protected _isValidDateInstance(date: D): boolean {\n        return this._adapter.isDateInstance(date) && this._adapter.isValid(date);\n    }\n\n    /** Adds a date to the current selection. */\n    abstract add(date: D | null): void;\n\n    /** Checks whether the current selection is valid. */\n    abstract isValid(): boolean;\n\n    /** Checks whether the current selection is complete. */\n    abstract isComplete(): boolean;\n}\n\n/**  A selection model that contains a single date. */\n@Injectable()\nexport class MatSingleDateSelectionModel<D> extends MatDateSelectionModel<D | null, D> {\n    constructor(adapter: DateAdapter<D>) {\n        super(null, adapter);\n    }\n\n    /**\n     * Adds a date to the current selection. In the case of a single date selection, the added date\n     * simply overwrites the previous selection\n     */\n    add(date: D | null) {\n        super.updateSelection(date, this);\n    }\n\n    /** Checks whether the current selection is valid. */\n    isValid(): boolean {\n        return this.selection != null && this._isValidDateInstance(this.selection);\n    }\n\n    /**\n     * Checks whether the current selection is complete. In the case of a single date selection, this\n     * is true if the current selection is not null.\n     */\n    isComplete() {\n        return this.selection != null;\n    }\n}\n\n/**  A selection model that contains a date range. */\n@Injectable()\nexport class MatRangeDateSelectionModel<D> extends MatDateSelectionModel<DateRange<D>, D> {\n\n    constructor(adapter: DateAdapter<D>) {\n        super(new DateRange<D>(null, null), adapter);\n    }\n\n    /**\n     * Adds a date to the current selection. In the case of a date range selection, the added date\n     * fills in the next `null` value in the range. If both the start and the end already have a date,\n     * the selection is reset so that the given date is the new `start` and the `end` is null.\n     */\n    add(date: D | null): void {\n        let { start, end } = this.selection;\n\n        if (start == null) {\n            start = date;\n        } else if (end == null) {\n            end = date;\n        } else {\n            start = date;\n            end = null;\n        }\n\n        super.updateSelection(new DateRange<D>(start, end), this);\n    }\n\n    /** Checks whether the current selection is valid. */\n    isValid(): boolean {\n        const { start, end } = this.selection;\n\n        // Empty ranges are valid.\n        if (start == null && end == null) {\n            return true;\n        }\n\n        // Complete ranges are only valid if both dates are valid and the start is before the end.\n        if (start != null && end != null) {\n            return this._isValidDateInstance(start) && this._isValidDateInstance(end) &&\n                this._adapter.compareDate(start, end) <= 0;\n        }\n\n        // Partial ranges are valid if the start/end is valid.\n        return (start == null || this._isValidDateInstance(start)) &&\n            (end == null || this._isValidDateInstance(end));\n    }\n\n    /**\n     * Checks whether the current selection is complete. In the case of a date range selection, this\n     * is true if the current selection has a non-null `start` and `end`.\n     */\n    isComplete(): boolean {\n        return this.selection.start != null && this.selection.end != null;\n    }\n}\n\n/** @docs-private */\nexport function MAT_SINGLE_DATE_SELECTION_MODEL_FACTORY(parent: MatSingleDateSelectionModel<unknown>, adapter: DateAdapter<unknown>) {\n    return parent || new MatSingleDateSelectionModel(adapter);\n}\n\n/** Used to provide a single selection model to a component. */\nexport const MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER: FactoryProvider = {\n    provide: MatDateSelectionModel,\n    deps: [[new Optional(), new SkipSelf(), MatDateSelectionModel], DateAdapter],\n    useFactory: MAT_SINGLE_DATE_SELECTION_MODEL_FACTORY,\n};\n\n\n/** @docs-private */\nexport function MAT_RANGE_DATE_SELECTION_MODEL_FACTORY(parent: MatSingleDateSelectionModel<unknown>, adapter: DateAdapter<unknown>) {\n    return parent || new MatRangeDateSelectionModel(adapter);\n}\n\n/** Used to provide a range selection model to a component. */\nexport const MAT_RANGE_DATE_SELECTION_MODEL_PROVIDER: FactoryProvider = {\n    provide: MatDateSelectionModel,\n    deps: [[new Optional(), new SkipSelf(), MatDateSelectionModel], DateAdapter],\n    useFactory: MAT_RANGE_DATE_SELECTION_MODEL_FACTORY,\n};\n"]}

package/esm2015/shared/gipi-components/datepicker/mat-datepicker/datepicker-animations.js

@@ -0,0 +1,35 @@
+/**
+ * @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 { animate, state, style, transition, trigger, } from '@angular/animations';
+/**
+ * Animations used by the Material datepicker.
+ * @docs-private
+ */
+export const matDatepickerAnimations = {
+    /** Transforms the height of the datepicker's calendar. */
+    transformPanel: trigger('transformPanel', [
+        state('void', style({
+            opacity: 0,
+            transform: 'scale(1, 0.8)'
+        })),
+        transition('void => enter', animate('120ms cubic-bezier(0, 0, 0.2, 1)', style({
+            opacity: 1,
+            transform: 'scale(1, 1)'
+        }))),
+        transition('* => void', animate('100ms linear', style({ opacity: 0 })))
+    ]),
+    /** Fades in the content of the calendar. */
+    fadeInCalendar: trigger('fadeInCalendar', [
+        state('void', style({ opacity: 0 })),
+        state('enter', style({ opacity: 1 })),
+        // TODO(crisbeto): this animation should be removed since it isn't quite on spec, but we
+        // need to keep it until #12440 gets in, otherwise the exit animation will look glitchy.
+        transition('void => *', animate('120ms 100ms cubic-bezier(0.55, 0, 0.55, 0.2)'))
+    ])
+};
+//# sourceMappingURL=data:application/json;base64,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