ngx-mat-datefns-date-adapter
Version:
[](https://github.com/sapozhnikovay/ngx-mat-datefns-date-adapter/blob/master/LICENSE) [](https://www.npmjs.com/package/ngx-ma
618 lines (605 loc) • 27.5 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/material/core'), require('date-fns'), require('date-fns-tz'), require('date-fns/locale')) :
typeof define === 'function' && define.amd ? define('ngx-mat-datefns-date-adapter', ['exports', '@angular/core', '@angular/material/core', 'date-fns', 'date-fns-tz', 'date-fns/locale'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global['ngx-mat-datefns-date-adapter'] = {}, global.ng.core, global.ng.material.core, global.dateFns, global['date-fns-tz'], global.locale));
}(this, (function (exports, core, core$1, dateFns, dateFnsTz, locale) { 'use strict';
var NGX_MAT_DATEFNS_DATE_FORMATS = {
parse: {
dateInput: 'P',
},
display: {
dateInput: 'P',
monthYearLabel: 'MMM yyyy',
dateA11yLabel: 'PP',
monthYearA11yLabel: 'MMMM yyyy',
},
};
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b)
if (Object.prototype.hasOwnProperty.call(b, p))
d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function () {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
r = Reflect.decorate(decorators, target, key, desc);
else
for (var i = decorators.length - 1; i >= 0; i--)
if (d = decorators[i])
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); };
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try {
step(generator.next(value));
}
catch (e) {
reject(e);
} }
function rejected(value) { try {
step(generator["throw"](value));
}
catch (e) {
reject(e);
} }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function () { if (t[0] & 1)
throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f)
throw new TypeError("Generator is already executing.");
while (_)
try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
return t;
if (y = 0, t)
op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2])
_.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
}
catch (e) {
op = [6, e];
y = 0;
}
finally {
f = t = 0;
}
if (op[0] & 5)
throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
}
var __createBinding = Object.create ? (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
}) : (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
o[k2] = m[k];
});
function __exportStar(m, o) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
__createBinding(o, m, p);
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m)
return m.call(o);
if (o && typeof o.length === "number")
return {
next: function () {
if (o && i >= o.length)
o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
}
catch (error) {
e = { error: error };
}
finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
}
finally {
if (e)
throw e.error;
}
}
return ar;
}
/** @deprecated */
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
/** @deprecated */
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++)
s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
function __spreadArray(to, from, pack) {
if (pack || arguments.length === 2)
for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar)
ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || from);
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n])
i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try {
step(g[n](v));
}
catch (e) {
settle(q[0][3], e);
} }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length)
resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) {
Object.defineProperty(cooked, "raw", { value: raw });
}
else {
cooked.raw = raw;
}
return cooked;
}
;
var __setModuleDefault = Object.create ? (function (o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function (o, v) {
o["default"] = v;
};
function __importStar(mod) {
if (mod && mod.__esModule)
return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
__createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, state, kind, f) {
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {
if (kind === "m")
throw new TypeError("Private method is not writable");
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
}
var NGX_MAT_DATEFNS_LOCALES = new core.InjectionToken('NGX_MAT_DATEFNS_LOCALES');
var NGX_MAT_DATEFNS_DATE_ADAPTER_OPTIONS = new core.InjectionToken('NGX_MAT_DATEFNS_DATE_ADAPTER_OPTIONS', {
providedIn: 'root',
factory: NGX_MAT_DATEFNS_DATE_ADAPTER_OPTIONS_FACTORY,
});
function NGX_MAT_DATEFNS_DATE_ADAPTER_OPTIONS_FACTORY() {
return {
useUtc: false,
};
}
function range(start, end) {
var arr = [];
for (var i = start; i <= end; i++) {
arr.push(i);
}
return arr;
}
var UTC_TIMEZONE = 'UTC';
var NgxDateFnsDateAdapter = /** @class */ (function (_super) {
__extends(NgxDateFnsDateAdapter, _super);
function NgxDateFnsDateAdapter(dateLocale, locales, options) {
var _this = _super.call(this) || this;
_this.locales = locales;
_this.options = options;
_this.getLocale = function (localeCodeOrLocale) {
if (localeCodeOrLocale && localeCodeOrLocale.code) {
return localeCodeOrLocale;
}
if (!_this.locales || !_this.locales.length) {
throw new Error('locales array does not provided or is empty. Provide it via the NGX_MAT_DATEFNS_LOCALES token.');
}
var locale = _this.locales.find(function (item) { return item.code === localeCodeOrLocale; });
if (!locale) {
throw new Error("locale '" + localeCodeOrLocale + "' does not exist in locales array. Add it to the NGX_MAT_DATEFNS_LOCALES token.");
}
return locale;
};
if (!_this.locales || _this.locales.length === 0) {
_this.locales = [locale.enUS];
}
try {
_this.setLocale(dateLocale || locale.enUS);
}
catch (err) {
_this.setLocale(locale.enUS);
}
return _this;
}
NgxDateFnsDateAdapter.prototype.setLocale = function (locale) {
if (!locale) {
throw new Error('setLocale should be called with the string locale code or date-fns Locale object');
}
this._dateFnsLocale = this.getLocale(locale);
_super.prototype.setLocale.call(this, locale);
};
NgxDateFnsDateAdapter.prototype.addCalendarDays = function (date, days) {
return dateFns.addDays(date, days);
};
NgxDateFnsDateAdapter.prototype.addCalendarMonths = function (date, months) {
return dateFns.addMonths(date, months);
};
NgxDateFnsDateAdapter.prototype.addCalendarYears = function (date, years) {
return dateFns.addYears(date, years);
};
NgxDateFnsDateAdapter.prototype.clone = function (date) {
return dateFns.toDate(date);
};
NgxDateFnsDateAdapter.prototype.createDate = function (year, month, date) {
// Check for invalid month and date (except upper bound on date which we have to check after
// creating the Date).
if (month < 0 || month > 11) {
throw Error("Invalid month index \"" + month + "\". Month index has to be between 0 and 11.");
}
if (date < 1) {
throw Error("Invalid date \"" + date + "\". Date has to be greater than 0.");
}
var result = this._createDateWithOverflow(year, month, date);
// Check that the date wasn't above the upper bound for the month, causing the month to overflow
if (result.getMonth() !== month) {
throw Error("Invalid date \"" + date + "\" for month with index \"" + month + "\".");
}
return result;
};
NgxDateFnsDateAdapter.prototype.deserialize = function (value) {
var _a;
if (value) {
if (typeof value === 'string') {
if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.useUtc) {
return dateFns.parseJSON(value);
}
return dateFns.parseISO(value);
}
if (typeof value === 'number') {
return dateFns.toDate(value);
}
if (value instanceof Date) {
return this.clone(value);
}
return null;
}
return null;
};
NgxDateFnsDateAdapter.prototype.format = function (date, displayFormat) {
return dateFns.format(date, displayFormat, { locale: this._dateFnsLocale });
};
NgxDateFnsDateAdapter.prototype.getDate = function (date) {
return dateFns.getDate(date);
};
NgxDateFnsDateAdapter.prototype.getDateNames = function () {
return range(1, 31).map(function (day) { return String(day); });
};
NgxDateFnsDateAdapter.prototype.getDayOfWeek = function (date) {
return dateFns.getDay(date);
};
NgxDateFnsDateAdapter.prototype.getDayOfWeekNames = function (style) {
var _this = this;
var map = {
long: 'EEEE',
short: 'EEE',
narrow: 'EEEEE',
};
var formatStr = map[style];
var date = new Date();
return range(0, 6).map(function (day) { return dateFns.format(dateFns.setDay(date, day), formatStr, {
locale: _this._dateFnsLocale,
}); });
};
NgxDateFnsDateAdapter.prototype.getFirstDayOfWeek = function () {
var _a, _b;
return (_b = (_a = this._dateFnsLocale.options) === null || _a === void 0 ? void 0 : _a.weekStartsOn) !== null && _b !== void 0 ? _b : 0;
};
NgxDateFnsDateAdapter.prototype.getMonth = function (date) {
return dateFns.getMonth(date);
};
NgxDateFnsDateAdapter.prototype.getMonthNames = function (style) {
var _this = this;
var map = {
long: 'LLLL',
short: 'LLL',
narrow: 'LLLLL',
};
var formatStr = map[style];
var date = new Date();
return range(0, 11).map(function (month) { return dateFns.format(dateFns.setMonth(date, month), formatStr, {
locale: _this._dateFnsLocale,
}); });
};
NgxDateFnsDateAdapter.prototype.getNumDaysInMonth = function (date) {
return dateFns.getDaysInMonth(date);
};
NgxDateFnsDateAdapter.prototype.getYear = function (date) {
return dateFns.getYear(date);
};
NgxDateFnsDateAdapter.prototype.getYearName = function (date) {
return dateFns.format(date, 'yyyy', {
locale: this._dateFnsLocale,
});
};
NgxDateFnsDateAdapter.prototype.invalid = function () {
return new Date(NaN);
};
NgxDateFnsDateAdapter.prototype.isDateInstance = function (obj) {
return obj instanceof Date;
};
NgxDateFnsDateAdapter.prototype.isValid = function (date) {
return date instanceof Date && !isNaN(date.getTime());
};
NgxDateFnsDateAdapter.prototype.parse = function (value, parseFormat) {
var _a;
if (value) {
if (typeof value === 'string') {
if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.useUtc) {
var d = dateFns.parse(value.trim(), parseFormat, new Date(), {
locale: this._dateFnsLocale,
});
return dateFnsTz.zonedTimeToUtc(d, UTC_TIMEZONE);
}
return dateFns.parse(value.trim(), parseFormat, new Date(), {
locale: this._dateFnsLocale,
});
}
if (typeof value === 'number') {
return dateFns.toDate(value);
}
if (value instanceof Date) {
return this.clone(value);
}
return null;
}
return null;
};
NgxDateFnsDateAdapter.prototype.toIso8601 = function (date) {
return date.toISOString();
};
NgxDateFnsDateAdapter.prototype.today = function () {
var d = new Date();
return this._createDateWithOverflow(d.getFullYear(), d.getMonth(), d.getDate());
};
/** Creates a date but allows the month and date to overflow. */
NgxDateFnsDateAdapter.prototype._createDateWithOverflow = function (year, month, date) {
var result = this._createDateInternal(year, month, date);
// We need to correct for the fact that JS native Date treats years in range [0, 99] as
// abbreviations for 19xx.
if (year >= 0 && year < 100) {
result.setFullYear(this.getYear(result) - 1900);
}
return result;
};
NgxDateFnsDateAdapter.prototype._createDateInternal = function (year, month, date) {
var _a;
if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.useUtc) {
return dateFnsTz.zonedTimeToUtc(new Date(year, month, date), UTC_TIMEZONE);
}
return new Date(year, month, date);
};
return NgxDateFnsDateAdapter;
}(core$1.DateAdapter));
NgxDateFnsDateAdapter.decorators = [
{ type: core.Injectable }
];
NgxDateFnsDateAdapter.ctorParameters = function () { return [
{ type: String, decorators: [{ type: core.Optional }, { type: core.Inject, args: [core$1.MAT_DATE_LOCALE,] }] },
{ type: Array, decorators: [{ type: core.Optional }, { type: core.Inject, args: [NGX_MAT_DATEFNS_LOCALES,] }] },
{ type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [NGX_MAT_DATEFNS_DATE_ADAPTER_OPTIONS,] }] }
]; };
var NgxDateFnsDateModule = /** @class */ (function () {
function NgxDateFnsDateModule() {
}
return NgxDateFnsDateModule;
}());
NgxDateFnsDateModule.decorators = [
{ type: core.NgModule, args: [{
providers: [
{
provide: core$1.DateAdapter,
useClass: NgxDateFnsDateAdapter,
deps: [core$1.MAT_DATE_LOCALE, NGX_MAT_DATEFNS_LOCALES, NGX_MAT_DATEFNS_DATE_ADAPTER_OPTIONS],
},
],
},] }
];
var ɵ0 = NGX_MAT_DATEFNS_DATE_FORMATS, ɵ1 = [];
var NgxMatDateFnsDateModule = /** @class */ (function () {
function NgxMatDateFnsDateModule() {
}
return NgxMatDateFnsDateModule;
}());
NgxMatDateFnsDateModule.decorators = [
{ type: core.NgModule, args: [{
imports: [NgxDateFnsDateModule],
providers: [
{ provide: core$1.MAT_DATE_FORMATS, useValue: ɵ0 },
{ provide: NGX_MAT_DATEFNS_LOCALES, useValue: ɵ1 },
],
},] }
];
/*
* Public API Surface of ngx-mat-datefns-date-adapter
*/
/**
* Generated bundle index. Do not edit.
*/
exports.NGX_MAT_DATEFNS_DATE_ADAPTER_OPTIONS = NGX_MAT_DATEFNS_DATE_ADAPTER_OPTIONS;
exports.NGX_MAT_DATEFNS_DATE_ADAPTER_OPTIONS_FACTORY = NGX_MAT_DATEFNS_DATE_ADAPTER_OPTIONS_FACTORY;
exports.NGX_MAT_DATEFNS_DATE_FORMATS = NGX_MAT_DATEFNS_DATE_FORMATS;
exports.NGX_MAT_DATEFNS_LOCALES = NGX_MAT_DATEFNS_LOCALES;
exports.NgxDateFnsDateAdapter = NgxDateFnsDateAdapter;
exports.NgxDateFnsDateModule = NgxDateFnsDateModule;
exports.NgxMatDateFnsDateModule = NgxMatDateFnsDateModule;
exports.ɵ0 = ɵ0;
exports.ɵ1 = ɵ1;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=ngx-mat-datefns-date-adapter.umd.js.map