@dhutaryan/ngx-mat-timepicker 0.0.1

package/esm2015/lib/adapter/native-date-time-adapter.js

@@ -0,0 +1,130 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { MAT_TIME_LOCALE, TimeAdapter } from './time-adapter';
+import * as i0 from "@angular/core";
+/**
+ * Matches strings that have the form of a valid RFC 3339 string
+ * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date
+ * because the regex will match strings an with out of bounds month, date, etc.
+ */
+const ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
+/** Adapts the native JS Date for components that work with time. */
+export class NativeDateTimeAdapter extends TimeAdapter {
+    constructor(matTimeLocale) {
+        super();
+        super.setLocale(matTimeLocale);
+    }
+    now() {
+        return new Date();
+    }
+    parse(value, parseFormat) {
+        // We have no way using the native JS Date to set the parse format or locale, so we ignore these
+        // parameters.
+        if (typeof value == 'number') {
+            return new Date(value);
+        }
+        const { hour, minute } = this.parseTime(value);
+        const date = new Date();
+        date.setHours(Number(hour));
+        date.setMinutes(Number(minute));
+        return value ? new Date(date) : null;
+    }
+    parseTime(value) {
+        const [hour, minute] = value
+            .replace(/(\sam|\spm|\sAM|\sPM|am|pm|AM|PM)/g, '')
+            .split(':');
+        return { hour, minute };
+    }
+    getHour(date) {
+        return date.getHours();
+    }
+    getMinute(date) {
+        return date.getMinutes();
+    }
+    updateHour(date, hour) {
+        const copy = new Date(date.getTime());
+        copy.setHours(hour);
+        return copy;
+    }
+    updateMinute(date, minute) {
+        const copy = new Date(date.getTime());
+        copy.setMinutes(minute);
+        return copy;
+    }
+    getPeriod(date) {
+        return date.getHours() < 12 ? 'am' : 'pm';
+    }
+    format(date, displayFormat) {
+        if (!this.isValid(date)) {
+            throw Error('NativeDateTimeAdapter: Cannot format invalid date.');
+        }
+        const dtf = new Intl.DateTimeFormat(this.locale, Object.assign(Object.assign({}, displayFormat), { timeZone: 'utc' }));
+        return this._format(dtf, date);
+    }
+    /**
+     * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings
+     * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an
+     * invalid date for all other values.
+     */
+    deserialize(value) {
+        if (typeof value === 'string') {
+            if (!value) {
+                return null;
+            }
+            // The `Date` constructor accepts formats other than ISO 8601, so we need to make sure the
+            // string is the right format first.
+            if (ISO_8601_REGEX.test(value)) {
+                const date = new Date(value);
+                if (this.isValid(date)) {
+                    return date;
+                }
+            }
+        }
+        return super.deserialize(value);
+    }
+    isTimeInstance(obj) {
+        return obj instanceof Date;
+    }
+    isValid(date) {
+        return !isNaN(date.getTime());
+    }
+    invalid() {
+        return new Date(NaN);
+    }
+    compareTime(first, second) {
+        return (first.getFullYear() - second.getFullYear() ||
+            first.getMonth() - second.getMonth() ||
+            first.getDate() - second.getDate() ||
+            first.getHours() - second.getHours() ||
+            first.getMinutes() - first.getMinutes());
+    }
+    /**
+     * When converting Date object to string, javascript built-in functions may return wrong
+     * results because it applies its internal DST rules. The DST rules around the world change
+     * very frequently, and the current valid rule is not always valid in previous years though.
+     * We work around this problem building a new Date object which has its internal UTC
+     * representation with the local date and time.
+     * @param dtf Intl.DateTimeFormat object, containing the desired string format. It must have
+     *    timeZone set to 'utc' to work fine.
+     * @param date Date from which we want to get the string representation according to dtf
+     * @returns A Date object with its UTC representation based on the passed in date info
+     */
+    _format(dtf, date) {
+        // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.
+        // To work around this we use `setUTCFullYear` and `setUTCHours` instead.
+        const d = new Date();
+        d.setUTCFullYear(date.getFullYear(), date.getMonth(), date.getDate());
+        d.setUTCHours(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+        return dtf.format(d);
+    }
+}
+NativeDateTimeAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NativeDateTimeAdapter, deps: [{ token: MAT_TIME_LOCALE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+NativeDateTimeAdapter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NativeDateTimeAdapter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NativeDateTimeAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MAT_TIME_LOCALE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"native-date-time-adapter.js","sourceRoot":"","sources":["../../../../../projects/mat-timepicker/src/lib/adapter/native-date-time-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\r\n\r\nimport { MAT_TIME_LOCALE, TimeAdapter } from './time-adapter';\r\nimport { MatTimePeriodType } from '../time-period';\r\n\r\n/**\r\n * Matches strings that have the form of a valid RFC 3339 string\r\n * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date\r\n * because the regex will match strings an with out of bounds month, date, etc.\r\n */\r\nconst ISO_8601_REGEX =\r\n  /^\\d{4}-\\d{2}-\\d{2}(?:T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|(?:(?:\\+|-)\\d{2}:\\d{2}))?)?$/;\r\n\r\n/** Adapts the native JS Date for components that work with time. */\r\n@Injectable()\r\nexport class NativeDateTimeAdapter extends TimeAdapter<Date> {\r\n  constructor(@Optional() @Inject(MAT_TIME_LOCALE) matTimeLocale: string) {\r\n    super();\r\n    super.setLocale(matTimeLocale);\r\n  }\r\n\r\n  now(): Date {\r\n    return new Date();\r\n  }\r\n\r\n  parse(value: any, parseFormat?: any): Date | null {\r\n    // We have no way using the native JS Date to set the parse format or locale, so we ignore these\r\n    // parameters.\r\n    if (typeof value == 'number') {\r\n      return new Date(value);\r\n    }\r\n\r\n    const { hour, minute } = this.parseTime(value);\r\n    const date = new Date();\r\n    date.setHours(Number(hour));\r\n    date.setMinutes(Number(minute));\r\n\r\n    return value ? new Date(date) : null;\r\n  }\r\n\r\n  parseTime(value: string) {\r\n    const [hour, minute] = value\r\n      .replace(/(\\sam|\\spm|\\sAM|\\sPM|am|pm|AM|PM)/g, '')\r\n      .split(':');\r\n\r\n    return { hour, minute };\r\n  }\r\n\r\n  getHour(date: Date): number {\r\n    return date.getHours();\r\n  }\r\n\r\n  getMinute(date: Date): number {\r\n    return date.getMinutes();\r\n  }\r\n\r\n  updateHour(date: Date, hour: number): Date {\r\n    const copy = new Date(date.getTime());\r\n    copy.setHours(hour);\r\n\r\n    return copy;\r\n  }\r\n\r\n  updateMinute(date: Date, minute: number): Date {\r\n    const copy = new Date(date.getTime());\r\n    copy.setMinutes(minute);\r\n\r\n    return copy;\r\n  }\r\n\r\n  getPeriod(date: Date): MatTimePeriodType {\r\n    return date.getHours() < 12 ? 'am' : 'pm';\r\n  }\r\n\r\n  format(date: Date, displayFormat: Object): string {\r\n    if (!this.isValid(date)) {\r\n      throw Error('NativeDateTimeAdapter: Cannot format invalid date.');\r\n    }\r\n\r\n    const dtf = new Intl.DateTimeFormat(this.locale, {\r\n      ...displayFormat,\r\n      timeZone: 'utc',\r\n    });\r\n\r\n    return this._format(dtf, date);\r\n  }\r\n\r\n  /**\r\n   * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings\r\n   * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an\r\n   * invalid date for all other values.\r\n   */\r\n  override deserialize(value: any): Date | null {\r\n    if (typeof value === 'string') {\r\n      if (!value) {\r\n        return null;\r\n      }\r\n      // The `Date` constructor accepts formats other than ISO 8601, so we need to make sure the\r\n      // string is the right format first.\r\n      if (ISO_8601_REGEX.test(value)) {\r\n        const date = new Date(value);\r\n        if (this.isValid(date)) {\r\n          return date;\r\n        }\r\n      }\r\n    }\r\n    return super.deserialize(value);\r\n  }\r\n\r\n  isTimeInstance(obj: any): boolean {\r\n    return obj instanceof Date;\r\n  }\r\n\r\n  isValid(date: Date): boolean {\r\n    return !isNaN(date.getTime());\r\n  }\r\n\r\n  invalid(): Date {\r\n    return new Date(NaN);\r\n  }\r\n\r\n  compareTime(first: Date, second: Date): number {\r\n    return (\r\n      first.getFullYear() - second.getFullYear() ||\r\n      first.getMonth() - second.getMonth() ||\r\n      first.getDate() - second.getDate() ||\r\n      first.getHours() - second.getHours() ||\r\n      first.getMinutes() - first.getMinutes()\r\n    );\r\n  }\r\n\r\n  /**\r\n   * When converting Date object to string, javascript built-in functions may return wrong\r\n   * results because it applies its internal DST rules. The DST rules around the world change\r\n   * very frequently, and the current valid rule is not always valid in previous years though.\r\n   * We work around this problem building a new Date object which has its internal UTC\r\n   * representation with the local date and time.\r\n   * @param dtf Intl.DateTimeFormat object, containing the desired string format. It must have\r\n   *    timeZone set to 'utc' to work fine.\r\n   * @param date Date from which we want to get the string representation according to dtf\r\n   * @returns A Date object with its UTC representation based on the passed in date info\r\n   */\r\n  private _format(dtf: Intl.DateTimeFormat, date: Date) {\r\n    // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.\r\n    // To work around this we use `setUTCFullYear` and `setUTCHours` instead.\r\n    const d = new Date();\r\n    d.setUTCFullYear(date.getFullYear(), date.getMonth(), date.getDate());\r\n    d.setUTCHours(\r\n      date.getHours(),\r\n      date.getMinutes(),\r\n      date.getSeconds(),\r\n      date.getMilliseconds()\r\n    );\r\n    return dtf.format(d);\r\n  }\r\n}\r\n"]}

package/esm2015/lib/adapter/time-adapter.js

@@ -0,0 +1,62 @@
+import { InjectionToken, LOCALE_ID } from '@angular/core';
+/** InjectionToken for timepicker that can be used to override default locale code. */
+export const MAT_TIME_LOCALE = new InjectionToken('MAT_TIME_LOCALE');
+/** Provider for MAT_TIME_LOCALE injection token. */
+export const MAT_TIME_LOCALE_PROVIDER = {
+    provide: MAT_TIME_LOCALE,
+    useExisting: LOCALE_ID,
+};
+export class TimeAdapter {
+    /**
+     * Given a potential time object, returns that same time object if it is
+     * a valid time, or `null` if it's not a valid time.
+     * @param obj The object to check.
+     * @returns A time or `null`.
+     */
+    getValidTimeOrNull(obj) {
+        return this.isTimeInstance(obj) && this.isValid(obj)
+            ? obj
+            : null;
+    }
+    /**
+     * Attempts to deserialize a value to a valid time object. The `<mat-timepicker>` will call this
+     * method on all of its `@Input()` properties that accept time. It is therefore possible to
+     * support passing values from your backend directly to these properties by overriding this method
+     * to also deserialize the format used by your backend.
+     * @param value The value to be deserialized into a time object.
+     * @returns The deserialized time object, either a valid time, null if the value can be
+     *     deserialized into a null time (e.g. the empty string), or an invalid date.
+     */
+    deserialize(value) {
+        if (value == null || (this.isTimeInstance(value) && this.isValid(value))) {
+            return value;
+        }
+        return this.invalid();
+    }
+    /**
+     * Sets the locale used for all time.
+     * @param locale The new locale.
+     */
+    setLocale(locale) {
+        this.locale = locale;
+    }
+    /**
+     * Checks if two time are equal.
+     * @param first The first time to check.
+     * @param second The second time to check.
+     * @returns Whether the two time are equal.
+     *     Null time are considered equal to other null time.
+     */
+    sameTime(first, second) {
+        if (first && second) {
+            let firstValid = this.isValid(first);
+            let secondValid = this.isValid(second);
+            if (firstValid && secondValid) {
+                return !this.compareTime(first, second);
+            }
+            return firstValid == secondValid;
+        }
+        return first == second;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-adapter.js","sourceRoot":"","sources":["../../../../../projects/mat-timepicker/src/lib/adapter/time-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG1D,sFAAsF;AACtF,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,cAAc,CAAS,iBAAiB,CAAC,CAAC;AAE7E,oDAAoD;AACpD,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,OAAO,EAAE,eAAe;IACxB,WAAW,EAAE,SAAS;CACvB,CAAC;AAEF,MAAM,OAAgB,WAAW;IAoF/B;;;;;OAKG;IACH,kBAAkB,CAAC,GAAY;QAC7B,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,GAAQ,CAAC;YACvD,CAAC,CAAE,GAAS;YACZ,CAAC,CAAC,IAAI,CAAC;IACX,CAAC;IAED;;;;;;;;OAQG;IACH,WAAW,CAAC,KAAU;QACpB,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE;YACxE,OAAO,KAAK,CAAC;SACd;QACD,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;IACxB,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,MAAS;QACjB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAWD;;;;;;OAMG;IACH,QAAQ,CAAC,KAAe,EAAE,MAAgB;QACxC,IAAI,KAAK,IAAI,MAAM,EAAE;YACnB,IAAI,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACrC,IAAI,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YACvC,IAAI,UAAU,IAAI,WAAW,EAAE;gBAC7B,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;aACzC;YACD,OAAO,UAAU,IAAI,WAAW,CAAC;SAClC;QACD,OAAO,KAAK,IAAI,MAAM,CAAC;IACzB,CAAC;CACF","sourcesContent":["import { InjectionToken, LOCALE_ID } from '@angular/core';\r\nimport { MatTimePeriodType } from '../time-period';\r\n\r\n/** InjectionToken for timepicker that can be used to override default locale code. */\r\nexport const MAT_TIME_LOCALE = new InjectionToken<string>('MAT_TIME_LOCALE');\r\n\r\n/** Provider for MAT_TIME_LOCALE injection token. */\r\nexport const MAT_TIME_LOCALE_PROVIDER = {\r\n  provide: MAT_TIME_LOCALE,\r\n  useExisting: LOCALE_ID,\r\n};\r\n\r\nexport abstract class TimeAdapter<T, L = any> {\r\n  /** The locale to use for time. */\r\n  protected locale: L;\r\n\r\n  /**\r\n   * Gets now's time.\r\n   * @returns Now's time.\r\n   */\r\n  abstract now(): T;\r\n\r\n  /**\r\n   * Parses a time from a user-provided value.\r\n   * @param value The value to parse.\r\n   * @param parseFormat The expected format of the value being parsed\r\n   *     (type is implementation-dependent).\r\n   * @returns The parsed time.\r\n   */\r\n  abstract parse(value: any, parseFormat: any): T | null;\r\n\r\n  /**\r\n   * Gets the hour component of the given time.\r\n   * @param time The time to extract the hour from.\r\n   * @returns The hour component.\r\n   */\r\n  abstract getHour(time: T): number;\r\n\r\n  /**\r\n   * Gets the minute component of the given time.\r\n   * @param time The time to extract the minute from.\r\n   * @returns The minute component.\r\n   */\r\n  abstract getMinute(time: T): number;\r\n\r\n  /**\r\n   * Update the hour component of the given time.\r\n   * @param time The time to update the hour.\r\n   * @param hour The new hour to update given time.\r\n   * @returns The new time with updated hour component.\r\n   */\r\n  abstract updateHour(time: T, hour: number): T;\r\n\r\n  /**\r\n   * Update the minute component of the given time.\r\n   * @param time The time to update the minute.\r\n   * @param minute The new minute to update given time.\r\n   * @returns The new time with updated minute component.\r\n   */\r\n  abstract updateMinute(time: T, minute: number): T;\r\n\r\n  /**\r\n   * Gets the period component of the given time.\r\n   * @param time The time to extract the period from.\r\n   * @returns The period component.\r\n   */\r\n  abstract getPeriod(time: T): MatTimePeriodType;\r\n\r\n  /**\r\n   * Formats a time as a string according to the given format.\r\n   * @param time The value to format.\r\n   * @param displayFormat The format to use to display the time as a string.\r\n   * @returns The formatted time string.\r\n   */\r\n  abstract format(time: T, displayFormat: any): string;\r\n\r\n  /**\r\n   * Checks whether the given object is considered a time instance by this timeAdapter.\r\n   * @param obj The object to check\r\n   * @returns Whether the object is a time instance.\r\n   */\r\n  abstract isTimeInstance(obj: any): boolean;\r\n\r\n  /**\r\n   * Checks whether the given time is valid.\r\n   * @param time The time to check.\r\n   * @returns Whether the time is valid.\r\n   */\r\n  abstract isValid(time: T): boolean;\r\n\r\n  /**\r\n   * Gets time instance that is not valid.\r\n   * @returns An invalid time.\r\n   */\r\n  abstract invalid(): T;\r\n\r\n  /**\r\n   * Given a potential time object, returns that same time object if it is\r\n   * a valid time, or `null` if it's not a valid time.\r\n   * @param obj The object to check.\r\n   * @returns A time or `null`.\r\n   */\r\n  getValidTimeOrNull(obj: unknown): T | null {\r\n    return this.isTimeInstance(obj) && this.isValid(obj as T)\r\n      ? (obj as T)\r\n      : null;\r\n  }\r\n\r\n  /**\r\n   * Attempts to deserialize a value to a valid time object. The `<mat-timepicker>` will call this\r\n   * method on all of its `@Input()` properties that accept time. It is therefore possible to\r\n   * support passing values from your backend directly to these properties by overriding this method\r\n   * to also deserialize the format used by your backend.\r\n   * @param value The value to be deserialized into a time object.\r\n   * @returns The deserialized time object, either a valid time, null if the value can be\r\n   *     deserialized into a null time (e.g. the empty string), or an invalid date.\r\n   */\r\n  deserialize(value: any): T | null {\r\n    if (value == null || (this.isTimeInstance(value) && this.isValid(value))) {\r\n      return value;\r\n    }\r\n    return this.invalid();\r\n  }\r\n\r\n  /**\r\n   * Sets the locale used for all time.\r\n   * @param locale The new locale.\r\n   */\r\n  setLocale(locale: L) {\r\n    this.locale = locale;\r\n  }\r\n\r\n  /**\r\n   * Compares two time.\r\n   * @param first The first time to compare.\r\n   * @param second The second time to compare.\r\n   * @returns 0 if the time are equal, a number less than 0 if the first time is earlier,\r\n   *     a number greater than 0 if the first time is later.\r\n   */\r\n  abstract compareTime(first: T, second: T): number;\r\n\r\n  /**\r\n   * Checks if two time are equal.\r\n   * @param first The first time to check.\r\n   * @param second The second time to check.\r\n   * @returns Whether the two time are equal.\r\n   *     Null time are considered equal to other null time.\r\n   */\r\n  sameTime(first: T | null, second: T | null): boolean {\r\n    if (first && second) {\r\n      let firstValid = this.isValid(first);\r\n      let secondValid = this.isValid(second);\r\n      if (firstValid && secondValid) {\r\n        return !this.compareTime(first, second);\r\n      }\r\n      return firstValid == secondValid;\r\n    }\r\n    return first == second;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/clock-dials.js

@@ -0,0 +1,59 @@
+import { Component, ChangeDetectionStrategy, ViewEncapsulation, Optional, } from '@angular/core';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { MatTimeFaceBase } from './time-face-base';
+import { withZeroPrefix } from './time-inputs';
+import * as i0 from "@angular/core";
+import * as i1 from "./adapter";
+import * as i2 from "./timepicker-content-layout";
+import * as i3 from "./time-period";
+import * as i4 from "./hours-clock-dial";
+import * as i5 from "./minutes-clock-dial";
+import * as i6 from "@angular/common";
+export class MatClockDials extends MatTimeFaceBase {
+    constructor(_timeAdapter) {
+        super(_timeAdapter);
+        this.isHoursView = true;
+        /** Specifies the view of clock dial. */
+        this._view = new BehaviorSubject('hours');
+        this._viewSubscription = Subscription.EMPTY;
+    }
+    ngOnInit() {
+        this._viewSubscription = this._view.subscribe((view) => (this.isHoursView = view === 'hours'));
+    }
+    ngOnDestroy() {
+        var _a;
+        (_a = this._viewSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this._viewSubscription = null;
+    }
+    /** Changes clock dial view. */
+    onViewChange(view) {
+        this._view.next(view);
+    }
+    _withZeroPrefix(value) {
+        return withZeroPrefix(value, this.isMeridiem);
+    }
+    /** Handles hour selection. */
+    _onHourChanged(hour) {
+        this._view.next('minutes');
+        this._onHourSelected(hour);
+    }
+}
+MatClockDials.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MatClockDials, deps: [{ token: i1.TimeAdapter, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+MatClockDials.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: MatClockDials, selector: "mat-clock-dials", host: { classAttribute: "mat-clock-dials" }, exportAs: ["matClockDials"], usesInheritance: true, ngImport: i0, template: "<mat-timepicker-content-layout title=\"Select time\">\r\n  <div\r\n    class=\"mat-clock-dial-value\"\r\n    hours\r\n    [class.mat-clock-dial-value-active]=\"isHoursView\"\r\n    (click)=\"onViewChange('hours')\"\r\n  >\r\n    {{ _withZeroPrefix(selectedHour) }}\r\n  </div>\r\n  <div\r\n    class=\"mat-clock-dial-value\"\r\n    minutes\r\n    [class.mat-clock-dial-value-active]=\"!isHoursView\"\r\n    (click)=\"onViewChange('minutes')\"\r\n  >\r\n    {{ _withZeroPrefix(selectedMinute) }}\r\n  </div>\r\n\r\n  <ng-template mat-time-period [ngIf]=\"isMeridiem\">\r\n    <mat-time-period\r\n      [period]=\"period\"\r\n      (periodChanged)=\"_onPeriodChanged($event)\"\r\n    ></mat-time-period>\r\n  </ng-template>\r\n\r\n  <div class=\"mat-clock-dial-faces\">\r\n    <ng-template [ngIf]=\"isHoursView\">\r\n      <mat-hours-clock-dial\r\n        [selectedHour]=\"selectedHour\"\r\n        [isMeridiem]=\"isMeridiem\"\r\n        (selectedChange)=\"_onHourChanged($event)\"\r\n      ></mat-hours-clock-dial>\r\n    </ng-template>\r\n    <ng-template [ngIf]=\"!isHoursView\">\r\n      <mat-minutes-clock-dial\r\n        [selectedMinute]=\"selectedMinute\"\r\n        (selectedChange)=\"_onMinuteSelected($event)\"\r\n      ></mat-minutes-clock-dial>\r\n    </ng-template>\r\n  </div>\r\n</mat-timepicker-content-layout>\r\n", styles: [".mat-clock-dial-values{display:flex;width:100%}.mat-clock-dial-value{display:flex;align-items:center;justify-content:center;height:4.375rem;border-radius:.25rem;cursor:pointer}.mat-clock-dial-faces{margin-top:2.25rem}\n"], components: [{ type: i2.MatTimepickerContentLayout, selector: "mat-timepicker-content-layout", inputs: ["title"], exportAs: ["matTimepickerContent"] }, { type: i3.MatTimePeriod, selector: "mat-time-period", inputs: ["vertical", "period"], outputs: ["periodChanged"] }, { type: i4.MatHoursClockDial, selector: "mat-hours-clock-dial", inputs: ["selectedHour", "isMeridiem"], outputs: ["selectedChange"], exportAs: ["matHoursClockDial"] }, { type: i5.MatMinutesClockDial, selector: "mat-minutes-clock-dial", inputs: ["selectedMinute"], outputs: ["selectedChange"], exportAs: ["matMinutesClockDial"] }], directives: [{ type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MatClockDials, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'mat-clock-dials',
+                    templateUrl: './clock-dials.html',
+                    styleUrls: ['./clock-dials.scss'],
+                    exportAs: 'matClockDials',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        class: 'mat-clock-dials',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TimeAdapter, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/hours-clock-dial.js

@@ -0,0 +1,159 @@
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, EventEmitter, Inject, Input, Output, ViewEncapsulation, } from '@angular/core';
+import { debounceTime, fromEvent, merge, take } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/button";
+import * as i2 from "@angular/common";
+const HOURS = Array(24)
+    .fill(null)
+    .map((_, i) => i);
+const CLOCK_RADIUS = 128;
+const CLOCK_TICK_RADIUS = 16;
+const CLOCK_CORRECTED_RADIUS = CLOCK_RADIUS - CLOCK_TICK_RADIUS;
+const CLOCK_OUTER_RADIUS = 100;
+const CLOCK_INNER_RADIUS = CLOCK_OUTER_RADIUS - CLOCK_TICK_RADIUS * 2;
+export class MatHoursClockDial {
+    constructor(_element, _cdr, _document, _window) {
+        this._element = _element;
+        this._cdr = _cdr;
+        this._document = _document;
+        this._window = _window;
+        /** Emits selected hour. */
+        this.selectedChange = new EventEmitter();
+        this.hours = [];
+    }
+    /** Selected hour. */
+    get selectedHour() {
+        return this._selectedHour;
+    }
+    set selectedHour(value) {
+        const edgeValue = this.isMeridiem ? 12 : 0;
+        this._selectedHour = value === 0 ? edgeValue : value;
+    }
+    /** Whether the clock uses 12 hour format. */
+    get isMeridiem() {
+        return this._isMeridiem;
+    }
+    set isMeridiem(value) {
+        this._isMeridiem = value;
+        const edgeValue = value ? 12 : 0;
+        this._selectedHour =
+            this._selectedHour === 0 ? edgeValue : this._selectedHour;
+    }
+    ngOnInit() {
+        this._initHours();
+    }
+    /** Hand styles based on selected hour. */
+    _handStyles() {
+        const deg = Math.round(this.selectedHour * (360 / (24 / 2)));
+        const radius = this._getRadius(this.selectedHour);
+        const height = radius;
+        const marginTop = CLOCK_RADIUS - radius;
+        return {
+            transform: `rotate(${deg}deg)`,
+            height: `${height}px`,
+            'margin-top': `${marginTop}px`,
+        };
+    }
+    /** Handles mouse and touch events on dial and document. */
+    _onMouseDown(event) {
+        this._setHour(event);
+        const eventsSubscription = merge(fromEvent(this._document, 'mousemove'), fromEvent(this._document, 'touchmove'))
+            .pipe(debounceTime(0))
+            .subscribe({
+            next: (event) => {
+                event.preventDefault();
+                this._setHour(event);
+            },
+        });
+        merge(fromEvent(this._document, 'mouseup'), fromEvent(this._document, 'touchend'))
+            .pipe(take(1))
+            .subscribe({
+            next: () => {
+                eventsSubscription.unsubscribe();
+                this.selectedChange.emit(this.selectedHour);
+            },
+        });
+    }
+    /** Changes selected hour based on coordinates. */
+    _setHour(event) {
+        const element = this._element.nativeElement;
+        const elementRect = element.getBoundingClientRect();
+        const width = element.offsetWidth;
+        const height = element.offsetHeight;
+        const pageX = event instanceof MouseEvent ? event.pageX : event.touches[0].pageX;
+        const pageY = event instanceof MouseEvent ? event.pageY : event.touches[0].pageY;
+        const x = width / 2 - (pageX - elementRect.left - this._window.scrollX);
+        const y = height / 2 - (pageY - elementRect.top - this._window.scrollY);
+        const unit = Math.PI / 6;
+        const atan2 = Math.atan2(-x, y);
+        const radian = atan2 < 0 ? Math.PI * 2 + atan2 : atan2;
+        const initialValue = Math.round(radian / unit);
+        const z = Math.sqrt(x * x + y * y);
+        const outer = z > CLOCK_OUTER_RADIUS - CLOCK_TICK_RADIUS;
+        const value = this._getHourValue(initialValue, outer);
+        this.selectedHour = value;
+        this._cdr.detectChanges();
+    }
+    /** Return value of hour. */
+    _getHourValue(value, outer) {
+        const edgeValue = value === 0 || value === 12;
+        if (outer || this.isMeridiem) {
+            return edgeValue ? 0 : value;
+        }
+        return edgeValue ? 12 : value + 12;
+    }
+    /** Creates list of hours. */
+    _initHours() {
+        const initialHours = this.isMeridiem ? HOURS.slice(1, 13) : HOURS;
+        this.hours = initialHours.map((hour) => {
+            const radian = (hour / 6) * Math.PI;
+            const radius = this._getRadius(hour);
+            return {
+                value: hour,
+                displayValue: hour === 0 ? '00' : String(hour),
+                left: CLOCK_CORRECTED_RADIUS + Math.sin(radian) * radius,
+                top: CLOCK_CORRECTED_RADIUS - Math.cos(radian) * radius,
+            };
+        });
+    }
+    /** Returns radius based on hour */
+    _getRadius(hour) {
+        if (this.isMeridiem) {
+            return CLOCK_OUTER_RADIUS;
+        }
+        const outer = hour >= 0 && hour < 12;
+        const radius = outer ? CLOCK_OUTER_RADIUS : CLOCK_INNER_RADIUS;
+        return radius;
+    }
+}
+MatHoursClockDial.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MatHoursClockDial, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: DOCUMENT }, { token: Window }], target: i0.ɵɵFactoryTarget.Component });
+MatHoursClockDial.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: MatHoursClockDial, selector: "mat-hours-clock-dial", inputs: { selectedHour: "selectedHour", isMeridiem: "isMeridiem" }, outputs: { selectedChange: "selectedChange" }, host: { listeners: { "mousedown": "_onMouseDown($event)" }, classAttribute: "mat-clock-dial mat-clock-dial-hours" }, exportAs: ["matHoursClockDial"], ngImport: i0, template: "<div class=\"mat-clock-dial-hand\" [ngStyle]=\"_handStyles()\"></div>\r\n<ng-template ngFor let-hour [ngForOf]=\"hours\">\r\n  <button\r\n    class=\"mat-clock-dial-cell mat-elevation-z0\"\r\n    mat-mini-fab\r\n    disableRipple\r\n    [style.left.px]=\"hour.left\"\r\n    [style.top.px]=\"hour.top\"\r\n    [color]=\"selectedHour === hour.value ? 'primary' : undefined\"\r\n  >\r\n    {{ hour.displayValue }}\r\n  </button>\r\n</ng-template>\r\n", styles: [".mat-clock-dial{position:relative;display:block;width:16rem;height:16rem;margin:0 auto;border-radius:50%}.mat-clock-dial:before{position:absolute;top:50%;left:50%;width:.4375rem;height:.4375rem;border-radius:50%;transform:translate(-50%,-50%);content:\"\"}.mat-clock-dial [mat-mini-fab]{box-shadow:none}.mat-clock-dial-cell{position:absolute;display:flex;align-items:center;justify-content:center;width:2rem;height:2rem;border-radius:50%}.mat-clock-dial-hand{position:absolute;top:0;right:0;bottom:0;left:0;width:1px;margin:0 auto;transform-origin:bottom}.mat-clock-dial-hand:before{position:absolute;top:calc(.5rem / -2);left:calc(.5rem / -2);width:calc(.5rem + 1px);height:calc(.5rem + 1px);border-radius:50%;content:\"\"}\n"], components: [{ type: i1.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }], directives: [{ type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MatHoursClockDial, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'mat-hours-clock-dial',
+                    templateUrl: 'hours-clock-dial.html',
+                    styleUrls: ['clock-dial.scss'],
+                    exportAs: 'matHoursClockDial',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        class: 'mat-clock-dial mat-clock-dial-hours',
+                        '(mousedown)': '_onMouseDown($event)',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: Window, decorators: [{
+                    type: Inject,
+                    args: [Window]
+                }] }]; }, propDecorators: { selectedHour: [{
+                type: Input
+            }], isMeridiem: [{
+                type: Input
+            }], selectedChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hours-clock-dial.js","sourceRoot":"","sources":["../../../../projects/mat-timepicker/src/lib/hours-clock-dial.ts","../../../../projects/mat-timepicker/src/lib/hours-clock-dial.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EACL,uBAAuB,EAEvB,SAAS,EAET,YAAY,EACZ,MAAM,EACN,KAAK,EAEL,MAAM,EACN,iBAAiB,GAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;;;;AAS5D,MAAM,KAAK,GAAG,KAAK,CAAC,EAAE,CAAC;KACpB,IAAI,CAAC,IAAI,CAAC;KACV,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AACpB,MAAM,YAAY,GAAG,GAAG,CAAC;AACzB,MAAM,iBAAiB,GAAG,EAAE,CAAC;AAC7B,MAAM,sBAAsB,GAAG,YAAY,GAAG,iBAAiB,CAAC;AAChE,MAAM,kBAAkB,GAAG,GAAG,CAAC;AAC/B,MAAM,kBAAkB,GAAG,kBAAkB,GAAG,iBAAiB,GAAG,CAAC,CAAC;AActE,MAAM,OAAO,iBAAiB;IA8B5B,YACU,QAAiC,EACjC,IAAuB,EACL,SAAmB,EACrB,OAAe;QAH/B,aAAQ,GAAR,QAAQ,CAAyB;QACjC,SAAI,GAAJ,IAAI,CAAmB;QACL,cAAS,GAAT,SAAS,CAAU;QACrB,YAAO,GAAP,OAAO,CAAQ;QATzC,2BAA2B;QACjB,mBAAc,GAAG,IAAI,YAAY,EAAU,CAAC;QAE/C,UAAK,GAAwB,EAAE,CAAC;IAOpC,CAAC;IAlCJ,qBAAqB;IACrB,IACI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IACD,IAAI,YAAY,CAAC,KAAa;QAC5B,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3C,IAAI,CAAC,aAAa,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC;IACvD,CAAC;IAGD,6CAA6C;IAC7C,IACI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IACD,IAAI,UAAU,CAAC,KAAc;QAC3B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACjC,IAAI,CAAC,aAAa;YAChB,IAAI,CAAC,aAAa,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC;IAC9D,CAAC;IAeD,QAAQ;QACN,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAED,0CAA0C;IAC1C,WAAW;QACT,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7D,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAClD,MAAM,MAAM,GAAG,MAAM,CAAC;QACtB,MAAM,SAAS,GAAG,YAAY,GAAG,MAAM,CAAC;QAExC,OAAO;YACL,SAAS,EAAE,UAAU,GAAG,MAAM;YAC9B,MAAM,EAAE,GAAG,MAAM,IAAI;YACrB,YAAY,EAAE,GAAG,SAAS,IAAI;SAC/B,CAAC;IACJ,CAAC;IAED,2DAA2D;IAC3D,YAAY,CAAC,KAA8B;QACzC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAErB,MAAM,kBAAkB,GAAG,KAAK,CAC9B,SAAS,CAAa,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,EAClD,SAAS,CAAa,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,CACnD;aACE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;aACrB,SAAS,CAAC;YACT,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE;gBACd,KAAK,CAAC,cAAc,EAAE,CAAC;gBACvB,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACvB,CAAC;SACF,CAAC,CAAC;QAEL,KAAK,CACH,SAAS,CAAa,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,EAChD,SAAS,CAAa,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,CAClD;aACE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACb,SAAS,CAAC;YACT,IAAI,EAAE,GAAG,EAAE;gBACT,kBAAkB,CAAC,WAAW,EAAE,CAAC;gBACjC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAC9C,CAAC;SACF,CAAC,CAAC;IACP,CAAC;IAED,kDAAkD;IAC1C,QAAQ,CAAC,KAA8B;QAC7C,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC;QAC5C,MAAM,WAAW,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC;QACpD,MAAM,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC;QAClC,MAAM,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QACpC,MAAM,KAAK,GACT,KAAK,YAAY,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACrE,MAAM,KAAK,GACT,KAAK,YAAY,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACrE,MAAM,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,KAAK,GAAG,WAAW,CAAC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACxE,MAAM,CAAC,GAAG,MAAM,GAAG,CAAC,GAAG,CAAC,KAAK,GAAG,WAAW,CAAC,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACxE,MAAM,IAAI,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;QACzB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAChC,MAAM,MAAM,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;QACvD,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;QAC/C,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QACnC,MAAM,KAAK,GAAG,CAAC,GAAG,kBAAkB,GAAG,iBAAiB,CAAC;QACzD,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;QACtD,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;IAC5B,CAAC;IAED,4BAA4B;IACpB,aAAa,CAAC,KAAa,EAAE,KAAc;QACjD,MAAM,SAAS,GAAG,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;QAE9C,IAAI,KAAK,IAAI,IAAI,CAAC,UAAU,EAAE;YAC5B,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;SAC9B;QAED,OAAO,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;IACrC,CAAC;IAED,6BAA6B;IACrB,UAAU;QAChB,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAElE,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;YACrC,MAAM,MAAM,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC;YACpC,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAErC,OAAO;gBACL,KAAK,EAAE,IAAI;gBACX,YAAY,EAAE,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC;gBAC9C,IAAI,EAAE,sBAAsB,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM;gBACxD,GAAG,EAAE,sBAAsB,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM;aACxD,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,mCAAmC;IAC3B,UAAU,CAAC,IAAY;QAC7B,IAAI,IAAI,CAAC,UAAU,EAAE;YACnB,OAAO,kBAAkB,CAAC;SAC3B;QAED,MAAM,KAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,GAAG,EAAE,CAAC;QACrC,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,kBAAkB,CAAC;QAE/D,OAAO,MAAM,CAAC;IAChB,CAAC;;+GAjJU,iBAAiB,6EAiClB,QAAQ,aACR,MAAM;mGAlCL,iBAAiB,qUC3C9B,icAaA;4FD8Ba,iBAAiB;kBAZ7B,SAAS;mBAAC;oBACT,QAAQ,EAAE,sBAAsB;oBAChC,WAAW,EAAE,uBAAuB;oBACpC,SAAS,EAAE,CAAC,iBAAiB,CAAC;oBAC9B,QAAQ,EAAE,mBAAmB;oBAC7B,eAAe,EAAE,uBAAuB,CAAC,MAAM;oBAC/C,aAAa,EAAE,iBAAiB,CAAC,IAAI;oBACrC,IAAI,EAAE;wBACJ,KAAK,EAAE,qCAAqC;wBAC5C,aAAa,EAAE,sBAAsB;qBACtC;iBACF;mHAkCwC,QAAQ;0BAA5C,MAAM;2BAAC,QAAQ;8BACiB,MAAM;0BAAtC,MAAM;2BAAC,MAAM;4CA/BZ,YAAY;sBADf,KAAK;gBAYF,UAAU;sBADb,KAAK;gBAaI,cAAc;sBAAvB,MAAM","sourcesContent":["import { DOCUMENT } from '@angular/common';\r\nimport {\r\n  ChangeDetectionStrategy,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ElementRef,\r\n  EventEmitter,\r\n  Inject,\r\n  Input,\r\n  OnInit,\r\n  Output,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\nimport { debounceTime, fromEvent, merge, take } from 'rxjs';\r\n\r\nexport interface ClockDialViewCell {\r\n  value: number;\r\n  displayValue: string;\r\n  left: number;\r\n  top: number;\r\n}\r\n\r\nconst HOURS = Array(24)\r\n  .fill(null)\r\n  .map((_, i) => i);\r\nconst CLOCK_RADIUS = 128;\r\nconst CLOCK_TICK_RADIUS = 16;\r\nconst CLOCK_CORRECTED_RADIUS = CLOCK_RADIUS - CLOCK_TICK_RADIUS;\r\nconst CLOCK_OUTER_RADIUS = 100;\r\nconst CLOCK_INNER_RADIUS = CLOCK_OUTER_RADIUS - CLOCK_TICK_RADIUS * 2;\r\n\r\n@Component({\r\n  selector: 'mat-hours-clock-dial',\r\n  templateUrl: 'hours-clock-dial.html',\r\n  styleUrls: ['clock-dial.scss'],\r\n  exportAs: 'matHoursClockDial',\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  encapsulation: ViewEncapsulation.None,\r\n  host: {\r\n    class: 'mat-clock-dial mat-clock-dial-hours',\r\n    '(mousedown)': '_onMouseDown($event)',\r\n  },\r\n})\r\nexport class MatHoursClockDial implements OnInit {\r\n  /** Selected hour. */\r\n  @Input()\r\n  get selectedHour(): number {\r\n    return this._selectedHour;\r\n  }\r\n  set selectedHour(value: number) {\r\n    const edgeValue = this.isMeridiem ? 12 : 0;\r\n    this._selectedHour = value === 0 ? edgeValue : value;\r\n  }\r\n  private _selectedHour: number;\r\n\r\n  /** Whether the clock uses 12 hour format. */\r\n  @Input()\r\n  get isMeridiem(): boolean {\r\n    return this._isMeridiem;\r\n  }\r\n  set isMeridiem(value: boolean) {\r\n    this._isMeridiem = value;\r\n    const edgeValue = value ? 12 : 0;\r\n    this._selectedHour =\r\n      this._selectedHour === 0 ? edgeValue : this._selectedHour;\r\n  }\r\n  private _isMeridiem: boolean;\r\n\r\n  /** Emits selected hour. */\r\n  @Output() selectedChange = new EventEmitter<number>();\r\n\r\n  public hours: ClockDialViewCell[] = [];\r\n\r\n  constructor(\r\n    private _element: ElementRef<HTMLElement>,\r\n    private _cdr: ChangeDetectorRef,\r\n    @Inject(DOCUMENT) private _document: Document,\r\n    @Inject(Window) private _window: Window\r\n  ) {}\r\n\r\n  ngOnInit(): void {\r\n    this._initHours();\r\n  }\r\n\r\n  /** Hand styles based on selected hour. */\r\n  _handStyles(): any {\r\n    const deg = Math.round(this.selectedHour * (360 / (24 / 2)));\r\n    const radius = this._getRadius(this.selectedHour);\r\n    const height = radius;\r\n    const marginTop = CLOCK_RADIUS - radius;\r\n\r\n    return {\r\n      transform: `rotate(${deg}deg)`,\r\n      height: `${height}px`,\r\n      'margin-top': `${marginTop}px`,\r\n    };\r\n  }\r\n\r\n  /** Handles mouse and touch events on dial and document. */\r\n  _onMouseDown(event: MouseEvent | TouchEvent): void {\r\n    this._setHour(event);\r\n\r\n    const eventsSubscription = merge(\r\n      fromEvent<MouseEvent>(this._document, 'mousemove'),\r\n      fromEvent<TouchEvent>(this._document, 'touchmove')\r\n    )\r\n      .pipe(debounceTime(0))\r\n      .subscribe({\r\n        next: (event) => {\r\n          event.preventDefault();\r\n          this._setHour(event);\r\n        },\r\n      });\r\n\r\n    merge(\r\n      fromEvent<MouseEvent>(this._document, 'mouseup'),\r\n      fromEvent<TouchEvent>(this._document, 'touchend')\r\n    )\r\n      .pipe(take(1))\r\n      .subscribe({\r\n        next: () => {\r\n          eventsSubscription.unsubscribe();\r\n          this.selectedChange.emit(this.selectedHour);\r\n        },\r\n      });\r\n  }\r\n\r\n  /** Changes selected hour based on coordinates. */\r\n  private _setHour(event: MouseEvent | TouchEvent): void {\r\n    const element = this._element.nativeElement;\r\n    const elementRect = element.getBoundingClientRect();\r\n    const width = element.offsetWidth;\r\n    const height = element.offsetHeight;\r\n    const pageX =\r\n      event instanceof MouseEvent ? event.pageX : event.touches[0].pageX;\r\n    const pageY =\r\n      event instanceof MouseEvent ? event.pageY : event.touches[0].pageY;\r\n    const x = width / 2 - (pageX - elementRect.left - this._window.scrollX);\r\n    const y = height / 2 - (pageY - elementRect.top - this._window.scrollY);\r\n    const unit = Math.PI / 6;\r\n    const atan2 = Math.atan2(-x, y);\r\n    const radian = atan2 < 0 ? Math.PI * 2 + atan2 : atan2;\r\n    const initialValue = Math.round(radian / unit);\r\n    const z = Math.sqrt(x * x + y * y);\r\n    const outer = z > CLOCK_OUTER_RADIUS - CLOCK_TICK_RADIUS;\r\n    const value = this._getHourValue(initialValue, outer);\r\n    this.selectedHour = value;\r\n    this._cdr.detectChanges();\r\n  }\r\n\r\n  /** Return value of hour. */\r\n  private _getHourValue(value: number, outer: boolean): number {\r\n    const edgeValue = value === 0 || value === 12;\r\n\r\n    if (outer || this.isMeridiem) {\r\n      return edgeValue ? 0 : value;\r\n    }\r\n\r\n    return edgeValue ? 12 : value + 12;\r\n  }\r\n\r\n  /** Creates list of hours. */\r\n  private _initHours(): void {\r\n    const initialHours = this.isMeridiem ? HOURS.slice(1, 13) : HOURS;\r\n\r\n    this.hours = initialHours.map((hour) => {\r\n      const radian = (hour / 6) * Math.PI;\r\n      const radius = this._getRadius(hour);\r\n\r\n      return {\r\n        value: hour,\r\n        displayValue: hour === 0 ? '00' : String(hour),\r\n        left: CLOCK_CORRECTED_RADIUS + Math.sin(radian) * radius,\r\n        top: CLOCK_CORRECTED_RADIUS - Math.cos(radian) * radius,\r\n      };\r\n    });\r\n  }\r\n\r\n  /** Returns radius based on hour */\r\n  private _getRadius(hour: number): number {\r\n    if (this.isMeridiem) {\r\n      return CLOCK_OUTER_RADIUS;\r\n    }\r\n\r\n    const outer = hour >= 0 && hour < 12;\r\n    const radius = outer ? CLOCK_OUTER_RADIUS : CLOCK_INNER_RADIUS;\r\n\r\n    return radius;\r\n  }\r\n}\r\n","<div class=\"mat-clock-dial-hand\" [ngStyle]=\"_handStyles()\"></div>\r\n<ng-template ngFor let-hour [ngForOf]=\"hours\">\r\n  <button\r\n    class=\"mat-clock-dial-cell mat-elevation-z0\"\r\n    mat-mini-fab\r\n    disableRipple\r\n    [style.left.px]=\"hour.left\"\r\n    [style.top.px]=\"hour.top\"\r\n    [color]=\"selectedHour === hour.value ? 'primary' : undefined\"\r\n  >\r\n    {{ hour.displayValue }}\r\n  </button>\r\n</ng-template>\r\n"]}