moh-common-lib
Version:
A library of Angular components, services, and styles for B.C. Government Ministry of Health (MoH).
389 lines • 32.3 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import * as tslib_1 from "tslib";
import { Component, Input, Output, EventEmitter, ViewChild, forwardRef } from '@angular/core';
import { NgxMyDatePickerDirective } from 'ngx-mydatepicker';
import { NgForm, ControlContainer, NG_VALUE_ACCESSOR } from '@angular/forms';
import { Base } from '../../models/base';
/**
* Component NPM package dependencies:
* a) moment
*
* This component reports the following errors.
* required
* dayOutOfRange
* yearDistantPast
* yearDistantFuture
* noFutureDatesAllowed
* invalidValue
*
* These messages can be changed by updated messages using the errorMessages interface/
* Ex. { required: 'This field is required', invalidValue: '{label} is invalid' }
* @record
*/
export function DateErrorMsg() { }
if (false) {
/** @type {?|undefined} */
DateErrorMsg.prototype.required;
/** @type {?|undefined} */
DateErrorMsg.prototype.dayOutOfRange;
/** @type {?|undefined} */
DateErrorMsg.prototype.yearDistantPast;
/** @type {?|undefined} */
DateErrorMsg.prototype.yearDistantFuture;
/** @type {?|undefined} */
DateErrorMsg.prototype.noPastDatesAllowed;
/** @type {?|undefined} */
DateErrorMsg.prototype.noFutureDatesAllowed;
/** @type {?|undefined} */
DateErrorMsg.prototype.invalidValue;
}
/**
* PRIME datepicker component. Largely a wrapper for ngx-mydatepicker
* https://github.com/kekeh/ngx-mydatepicker
*
* NOTE - YOU MUST INCLUDE NGX-MYDATEPICKER IN YOUR PARENT APPLICATION TO USE
* THIS COMPONENT! This is due to some poor implementation in ngx-mydatepicker.
* Make sure to use the same version that this library uses.
*/
var DatepickerComponent = /** @class */ (function (_super) {
tslib_1.__extends(DatepickerComponent, _super);
function DatepickerComponent() {
var _this = _super.call(this) || this;
/**
* Component size can be reduced, see Datepickersizes for options
*/
_this.size = DatepickerSizes.DEFAULT;
_this.dateChange = new EventEmitter();
_this.required = false;
/**
* Control visibility of the clear 'x' button on the mini datepicker.
*
* **'visible'** is default, button exists
*
* **'none'** means the element does not exist
*
* **'invisible'** means the element takes up space but is not visible / cannot be
* used.
*
* Invisible is useful when you want to make sure a datepicker is the same
* size as a visible one.
*/
_this.clearButton = 'visible';
/**
* Format for how to display the date to the user.
*/
_this.dateFormat = 'yyyy/mm/dd';
// Make enum accessible in HTML
_this.DatepickerSizes = DatepickerSizes;
_this._onChange = (/**
* @param {?} _
* @return {?}
*/
function (_) { });
_this._onTouched = (/**
* @return {?}
*/
function () { });
return _this;
}
/**
* @param {?} date
* @return {?}
*/
DatepickerComponent.prototype.convertDateToSimpleDate = /**
* @param {?} date
* @return {?}
*/
function (date) {
if (date === null || date === undefined) {
return null;
}
return {
year: date.getFullYear(),
month: date.getMonth() + 1,
day: date.getDate(),
};
};
/**
* @param {?} date
* @return {?}
*/
DatepickerComponent.prototype.convertSimpleDateToDate = /**
* @param {?} date
* @return {?}
*/
function (date) {
// When ngx-mydatepicker is cleared, it returns {year: 0, month: 0, day: 0}
if (date.year === 0) {
return null;
}
return new Date(date.year, date.month - 1, date.day);
};
/**
* @param {?} x
* @return {?}
*/
DatepickerComponent.prototype.isDate = /**
* @param {?} x
* @return {?}
*/
function (x) {
if (!x) {
return false;
}
return x.getDate !== undefined;
};
/**
* @return {?}
*/
DatepickerComponent.prototype.ngOnInit = /**
* @return {?}
*/
function () {
if (!this.errorMessages) {
this.errorMessages = {
required: this.labelText + ' is required.',
dayOutOfRange: 'Invalid ' + this.labelText + '.',
yearDistantPast: 'Invalid ' + this.labelText + '.',
yearDistantFuture: 'Invalid ' + this.labelText + '.',
noFutureDatesAllowed: 'Invalid ' + this.labelText + '.',
invalidValue: 'Invalid ' + this.labelText + '.'
};
}
this.datepickerOptions = {
dateFormat: this.dateFormat,
sunHighlight: false,
appendSelectorToBody: true,
};
if (this.size === DatepickerSizes.MINI) {
// Set width/height to 4/5 of default
this.datepickerOptions.selectorHeight = '185px';
this.datepickerOptions.selectorWidth = '201px';
}
if (this.isDate(this.disableSince)) {
this.datepickerOptions.disableSince = this.convertDateToSimpleDate(this.disableSince);
}
if (this.isDate(this.disableUntil)) {
this.datepickerOptions.disableUntil = this.convertDateToSimpleDate(this.disableSince);
}
if (this.onlyFutureDates) {
/** @type {?} */
var today = new Date();
this.datepickerOptions.disableUntil = this.convertDateToSimpleDate(today);
}
if (this.date) {
// Even if jsdate winds up being undefined, even defining this.model will
// set the input as non-empty and it'll satisfy the 'required' validation.
// So, we only add the model if there's actual data.
this.model = {
jsdate: this.date
};
}
};
/**
* @param {?} changes
* @return {?}
*/
DatepickerComponent.prototype.ngOnChanges = /**
* @param {?} changes
* @return {?}
*/
function (changes) {
// Parent component has passed in null, so we have to manually clear the input. This leads to 2 change detection cycles.
// We could refactor it down to one, but the performance hit is minimal for such a simple component.
if (this.date === null) {
this.clearDate();
this._onChange(null);
this._onTouched();
}
};
/**
* @param {?} event
* @return {?}
*/
DatepickerComponent.prototype.onDateChanged = /**
* @param {?} event
* @return {?}
*/
function (event) {
if (event.jsdate || event.jsdate === null) {
// Always emit a Date (or null)
this.dateChange.emit(event.jsdate);
this._onChange(event.jsdate);
this._onTouched();
}
};
/**
* @return {?}
*/
DatepickerComponent.prototype.clearDate = /**
* @return {?}
*/
function () {
if (this.ngxdp) {
// We don't need to emit here, because by changing date we'll trigger onDateChanged automatically.
this.date = null;
this.ngxdp.clearDate();
}
};
/**
* @param {?} fn
* @return {?}
*/
DatepickerComponent.prototype.registerOnChange = /**
* @param {?} fn
* @return {?}
*/
function (fn) {
this._onChange = fn;
};
/**
* @param {?} fn
* @return {?}
*/
DatepickerComponent.prototype.registerOnTouched = /**
* @param {?} fn
* @return {?}
*/
function (fn) {
this._onTouched = fn;
};
/**
* @param {?} obj
* @return {?}
*/
DatepickerComponent.prototype.writeValue = /**
* @param {?} obj
* @return {?}
*/
function (obj) {
this.model = {
jsdate: obj
};
};
DatepickerComponent.decorators = [
{ type: Component, args: [{
selector: 'common-datepicker',
template: "<div>\r\n <label><span>{{labelText}}</span>\r\n <div class=\"input-group\">\r\n\r\n <input class=\"form-control\" placeholder=\"YYYY/MM/DD\"\r\n ngx-mydatepicker name=\"datepicker-{{labelText}}-{{objectId}}\"\r\n [(ngModel)]=\"model\"\r\n [options]=\"datepickerOptions\"\r\n #dp=\"ngx-mydatepicker\"\r\n #dateEl='ngModel'\r\n (dateChanged)=\"onDateChanged($event)\"\r\n [required]='required'\r\n [disabled]=\"disabled\"\r\n autocomplete=\"off\"/>\r\n\r\n <span class=\"input-group-append float-label-append\">\r\n <button type=\"button\" class=\"btn btn-default\" (click)=\"dp.toggleCalendar()\">\r\n <i class=\"fa fa-calendar\"></i>\r\n </button>\r\n </span>\r\n </div>\r\n </label>\r\n</div>\r\n\r\n<!-- InvalidDateFormat comes from ngxmydatepicker, so we have a little less control over it. -->\r\n<div *ngIf=\"!disabled && dateEl.touched\"\r\n role=\"alert\"\r\n class='error-container'\r\n aria-live=\"assertive\">\r\n <div class=\"text-danger\"\r\n *ngIf=\"(dateEl?.errors?.required) && errorMessages?.required && !dateEl?.errors?.invalidDateFormat\">\r\n {{errorMessages.required}}\r\n </div>\r\n <!-- ngx-mydatepicker has it's own errors and we can't easily add our own, so we have reduced error messages. -->\r\n <!-- <div class=\"text-danger\"\r\n *ngIf=\"dateEl?.errors?.dayOutOfRange && errorMessages?.dayOutOfRange\">\r\n {{errorMessages.dayOutOfRange}}\r\n </div>\r\n <div class=\"text-danger\"\r\n *ngIf=\"dateEl?.errors?.yearDistantPast && errorMessages?.yearDistantPast\">\r\n {{errorMessages.yearDistantPast}}\r\n </div>\r\n <div class=\"text-danger\"\r\n *ngIf=\"dateEl?.errors?.yearDistantFuture && errorMessages?.yearDistantFuture\">\r\n {{errorMessages.yearDistantFuture}}\r\n </div>\r\n <div class=\"text-danger\"\r\n *ngIf=\"dateEl?.errors?.noPastDatesAllowed && errorMessages?.noPastDatesAllowed\">\r\n {{errorMessages.noPastDatesAllowed}}\r\n </div>\r\n\r\n <div class=\"text-danger\"\r\n *ngIf=\"dateEl?.errors?.noFutureDatesAllowed && errorMessages?.noFutureDatesAllowed\">\r\n {{errorMessages.noFutureDatesAllowed}}\r\n </div> -->\r\n <div class=\"text-danger\"\r\n *ngIf=\"(dateEl?.errors?.invalidValue || dateEl?.errors?.invalidDateFormat) && errorMessages?.invalidValue\">\r\n {{errorMessages.invalidValue}}\r\n </div>\r\n</div>\r\n",
/* Re-use the same ngForm that it's parent is using. The component will show
* up in its parents `this.form`, and will auto-update `this.form.valid`
*/
viewProviders: [{ provide: ControlContainer, useExisting: forwardRef((/**
* @return {?}
*/
function () { return NgForm; })) }],
providers: [
{
provide: NG_VALUE_ACCESSOR,
multi: true,
useExisting: forwardRef((/**
* @return {?}
*/
function () { return DatepickerComponent; }))
}
],
styles: [".datepicker--mini{display:flex;flex-wrap:nowrap}.datepicker--mini:not(.hide-clear)>.btn{border-top-right-radius:0;border-bottom-right-radius:0}.datepicker--mini .input-group-append .btn{padding:0 .5rem}.input-group-append{z-index:0}.float-label-append{margin-bottom:calc(.5rem + 2px)}.has-float-label{flex-basis:calc(100% - 36px)}input::-ms-clear{display:none}"]
}] }
];
/** @nocollapse */
DatepickerComponent.ctorParameters = function () { return []; };
DatepickerComponent.propDecorators = {
size: [{ type: Input }],
date: [{ type: Input }],
dateChange: [{ type: Output }],
disabled: [{ type: Input }],
labelText: [{ type: Input }],
required: [{ type: Input }],
disableUntil: [{ type: Input }],
disableSince: [{ type: Input }],
onlyFutureDates: [{ type: Input }],
clearButton: [{ type: Input }],
dateFormat: [{ type: Input }],
errorMessages: [{ type: Input }],
ngxdp: [{ type: ViewChild, args: ['dp',] }]
};
return DatepickerComponent;
}(Base));
export { DatepickerComponent };
if (false) {
/**
* Component size can be reduced, see Datepickersizes for options
* @type {?}
*/
DatepickerComponent.prototype.size;
/** @type {?} */
DatepickerComponent.prototype.date;
/** @type {?} */
DatepickerComponent.prototype.dateChange;
/** @type {?} */
DatepickerComponent.prototype.disabled;
/** @type {?} */
DatepickerComponent.prototype.labelText;
/** @type {?} */
DatepickerComponent.prototype.required;
/**
* Dates **before** disableUntil will not be valid selections. Maps to a ngx-mydatepicker option, but we convert IMyDate to Date
* @type {?}
*/
DatepickerComponent.prototype.disableUntil;
/**
* Dates **after** disableSince will not be valid selections. Maps to a ngx-mydatepicker option, but we convert IMyDate to Date
* @type {?}
*/
DatepickerComponent.prototype.disableSince;
/**
* Equivalent to setting disableBefore to tomorrow.
* @type {?}
*/
DatepickerComponent.prototype.onlyFutureDates;
/**
* Control visibility of the clear 'x' button on the mini datepicker.
*
* **'visible'** is default, button exists
*
* **'none'** means the element does not exist
*
* **'invisible'** means the element takes up space but is not visible / cannot be
* used.
*
* Invisible is useful when you want to make sure a datepicker is the same
* size as a visible one.
* @type {?}
*/
DatepickerComponent.prototype.clearButton;
/**
* Format for how to display the date to the user.
* @type {?}
*/
DatepickerComponent.prototype.dateFormat;
/** @type {?} */
DatepickerComponent.prototype.errorMessages;
/**
* Datetime model used to interface with ngx-datepicker.
* @type {?}
*/
DatepickerComponent.prototype.model;
/** @type {?} */
DatepickerComponent.prototype.DatepickerSizes;
/** @type {?} */
DatepickerComponent.prototype.ngxdp;
/**
* Default options for wrapped ngx-datepicker.
* @type {?}
*/
DatepickerComponent.prototype.datepickerOptions;
/** @type {?} */
DatepickerComponent.prototype._onChange;
/** @type {?} */
DatepickerComponent.prototype._onTouched;
}
/** @enum {string} */
var DatepickerSizes = {
MINI: 'mini',
DEFAULT: 'default',
};
export { DatepickerSizes };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker.component.js","sourceRoot":"ng://moh-common-lib/","sources":["lib/components/datepicker/datepicker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, Input, Output, EventEmitter, SimpleChanges, ViewChild, OnChanges, forwardRef } from '@angular/core';\r\nimport { INgxMyDpOptions, IMyDate, NgxMyDatePickerDirective } from 'ngx-mydatepicker';\r\nimport { NgForm, ControlContainer, NG_VALUE_ACCESSOR, ControlValueAccessor } from '@angular/forms';\r\nimport { Base } from '../../models/base';\r\n\r\n/**\r\n * Component NPM package dependencies:\r\n * a) moment\r\n *\r\n * This component reports the following errors.\r\n *    required\r\n *    dayOutOfRange\r\n *    yearDistantPast\r\n *    yearDistantFuture\r\n *    noFutureDatesAllowed\r\n *    invalidValue\r\n *\r\n *  These messages can be changed by updated messages using the errorMessages interface/\r\n *  Ex. { required: 'This field is required', invalidValue: '{label} is invalid' }\r\n */\r\n\r\nexport interface DateErrorMsg { // TODO: Remove - possible breaking change - currently datepicker uses it\r\n  required?: string;\r\n  dayOutOfRange?: string;\r\n  yearDistantPast?: string;\r\n  yearDistantFuture?: string;\r\n  noPastDatesAllowed?: string;\r\n  noFutureDatesAllowed?: string;\r\n  invalidValue?: string;\r\n}\r\n\r\n\r\n/**\r\n * PRIME datepicker component. Largely a wrapper for ngx-mydatepicker\r\n * https://github.com/kekeh/ngx-mydatepicker\r\n *\r\n * NOTE - YOU MUST INCLUDE NGX-MYDATEPICKER IN YOUR PARENT APPLICATION TO USE\r\n * THIS COMPONENT!  This is due to some poor implementation in ngx-mydatepicker.\r\n * Make sure to use the same version that this library uses.\r\n */\r\n@Component({\r\n  selector: 'common-datepicker',\r\n  templateUrl: './datepicker.component.html',\r\n  styleUrls: ['./datepicker.component.scss'],\r\n  /* Re-use the same ngForm that it's parent is using. The component will show\r\n   * up in its parents `this.form`, and will auto-update `this.form.valid`\r\n   */\r\n  viewProviders: [ { provide: ControlContainer, useExisting: forwardRef(() => NgForm ) } ],\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      multi: true,\r\n      useExisting: forwardRef(() => DatepickerComponent)\r\n    }\r\n  ]\r\n})\r\nexport class DatepickerComponent extends Base implements OnInit, OnChanges, ControlValueAccessor {\r\n  /** Component size can be reduced, see Datepickersizes for options */\r\n  @Input() size: DatepickerSizes = DatepickerSizes.DEFAULT;\r\n  @Input() date: Date;\r\n  @Output() dateChange = new EventEmitter<Date>();\r\n  @Input() disabled: boolean;\r\n  @Input() labelText: string;\r\n\r\n  @Input() required: boolean = false;\r\n\r\n\r\n  /** Dates **before** disableUntil will not be valid selections.  Maps to a ngx-mydatepicker option, but we convert IMyDate to Date  */\r\n  @Input() disableUntil: Date;\r\n\r\n  /** Dates **after** disableSince will not be valid selections.  Maps to a ngx-mydatepicker option, but we convert IMyDate to Date */\r\n  @Input() disableSince: Date;\r\n\r\n  /** Equivalent to setting disableBefore to tomorrow. */\r\n  @Input() onlyFutureDates: boolean;\r\n\r\n  /**\r\n   * Control visibility of the clear 'x' button on the mini datepicker.\r\n   *\r\n   * **'visible'** is default, button exists\r\n   *\r\n   * **'none'** means the element does not exist\r\n   *\r\n   * **'invisible'** means the element takes up space but is not visible / cannot be\r\n   * used.\r\n   *\r\n   * Invisible is useful when you want to make sure a datepicker is the same\r\n   * size as a visible one.\r\n   */\r\n  @Input() clearButton: 'visible' | 'invisible' | 'none' = 'visible';\r\n\r\n\r\n\r\n  /** Format for how to display the date to the user. */\r\n  @Input() dateFormat: string = 'yyyy/mm/dd';\r\n\r\n  @Input() errorMessages: DateErrorMsg;\r\n\r\n  /** Datetime model used to interface with ngx-datepicker. */\r\n  // model: any;\r\n  model: any;\r\n\r\n  // Make enum accessible in HTML\r\n  DatepickerSizes: typeof DatepickerSizes = DatepickerSizes;\r\n\r\n  @ViewChild('dp') ngxdp: NgxMyDatePickerDirective;\r\n\r\n  /** Default options for wrapped ngx-datepicker. */\r\n  datepickerOptions: INgxMyDpOptions;\r\n\r\n  public _onChange = (_: any) => {};\r\n  public _onTouched = () => {};\r\n\r\n  constructor() {\r\n    super();\r\n   }\r\n\r\n  convertDateToSimpleDate(date: Date): IMyDate {\r\n    if (date === null || date === undefined) { return null; }\r\n    return {\r\n      year: date.getFullYear(),\r\n      month: date.getMonth() + 1,\r\n      day: date.getDate(),\r\n    };\r\n  }\r\n\r\n  convertSimpleDateToDate(date: IMyDate): Date {\r\n    // When ngx-mydatepicker is cleared, it returns {year: 0, month: 0, day: 0}\r\n    if (date.year === 0) {\r\n      return null;\r\n    }\r\n    return new Date(date.year, date.month - 1, date.day);\r\n  }\r\n\r\n  isDate(x: any): x is Date {\r\n    if (!x) { return false; }\r\n    return x.getDate !== undefined;\r\n  }\r\n\r\n  ngOnInit() {\r\n    if (!this.errorMessages) {\r\n      this.errorMessages = {\r\n        required: this.labelText + ' is required.',\r\n        dayOutOfRange: 'Invalid ' + this.labelText + '.',\r\n        yearDistantPast: 'Invalid ' + this.labelText + '.',\r\n        yearDistantFuture: 'Invalid ' + this.labelText + '.',\r\n        noFutureDatesAllowed: 'Invalid ' + this.labelText + '.',\r\n        invalidValue: 'Invalid ' + this.labelText + '.'\r\n      };\r\n    }\r\n\r\n    this.datepickerOptions = {\r\n      dateFormat: this.dateFormat,\r\n      sunHighlight: false,\r\n      appendSelectorToBody: true,\r\n    };\r\n\r\n    if (this.size === DatepickerSizes.MINI) {\r\n      // Set width/height to 4/5 of default\r\n      this.datepickerOptions.selectorHeight = '185px';\r\n      this.datepickerOptions.selectorWidth = '201px';\r\n    }\r\n\r\n    if (this.isDate(this.disableSince)) {\r\n      this.datepickerOptions.disableSince = this.convertDateToSimpleDate(this.disableSince);\r\n    }\r\n\r\n    if (this.isDate(this.disableUntil)) {\r\n      this.datepickerOptions.disableUntil = this.convertDateToSimpleDate(this.disableSince);\r\n    }\r\n\r\n    if (this.onlyFutureDates) {\r\n      const today = new Date();\r\n      this.datepickerOptions.disableUntil = this.convertDateToSimpleDate(today);\r\n    }\r\n\r\n\r\n    if (this.date) {\r\n      // Even if jsdate winds up being undefined, even defining this.model will\r\n      // set the input as non-empty and it'll satisfy the 'required' validation.\r\n      // So, we only add the model if there's actual data.\r\n      this.model = {\r\n        jsdate: this.date\r\n      };\r\n    }\r\n\r\n\r\n  }\r\n\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    // Parent component has passed in null, so we have to manually clear the input. This leads to 2 change detection cycles.\r\n    // We could refactor it down to one, but the performance hit is minimal for such a simple component.\r\n    if (this.date === null) {\r\n      this.clearDate();\r\n      this._onChange(null);\r\n      this._onTouched();\r\n    }\r\n  }\r\n\r\n  onDateChanged(event): void {\r\n    if (event.jsdate || event.jsdate === null) {\r\n      // Always emit a Date (or null)\r\n      this.dateChange.emit(event.jsdate);\r\n      this._onChange(event.jsdate);\r\n      this._onTouched();\r\n    }\r\n  }\r\n\r\n  clearDate() {\r\n    if (this.ngxdp) {\r\n      // We don't need to emit here, because by changing date we'll trigger onDateChanged automatically.\r\n      this.date = null;\r\n      this.ngxdp.clearDate();\r\n    }\r\n  }\r\n\r\n  registerOnChange(fn: any): void {\r\n    this._onChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: any): void {\r\n    this._onTouched = fn;\r\n  }\r\n\r\n  writeValue(obj: any): void {\r\n    this.model = {\r\n      jsdate: obj\r\n    };\r\n  }\r\n}\r\n\r\nexport enum DatepickerSizes {\r\n  MINI = 'mini',\r\n  DEFAULT = 'default'\r\n}\r\n"]}