@teipublisher/pb-components 2.25.4 → 2.25.6

package/src/dts-select-endpoint.js

@@ -12,99 +12,107 @@ import '@polymer/paper-item';
  * The list may either be given as a JSON-formatted string within the
  * `endpoints` property or it can be loaded from a JSON file whose path
  * is specified via the `load` property.
- * 
+ *
  * The JSON should contain an array of objects, each having an `url` and
  * `title` property.
- * 
+ *
  * @fires dts-endpoint - Sets the endpoint
  */
 export class DtsSelectEndpoint extends pbMixin(LitElement) {
-    static get properties() {
-        return {
-            ...super.properties,
-            /**
-             * The currently selected endpoint. Will be set from URL parameter if present.
-             */
-            endpoint: {
-                type: String
-            },
-            label: {
-                type: String
-            },
-            /**
-             * Array of endpoints to select from, each being an object with
-             * properties `url` and `title`.
-             */
-            endpoints: {
-                type: Array
-            },
-            /**
-             * Set to true to automatically select the first endpoint
-             */
-            auto: {
-                type: Boolean
-            }
-        };
-    }
+  static get properties() {
+    return {
+      ...super.properties,
+      /**
+       * The currently selected endpoint. Will be set from URL parameter if present.
+       */
+      endpoint: {
+        type: String,
+      },
+      label: {
+        type: String,
+      },
+      /**
+       * Array of endpoints to select from, each being an object with
+       * properties `url` and `title`.
+       */
+      endpoints: {
+        type: Array,
+      },
+      /**
+       * Set to true to automatically select the first endpoint
+       */
+      auto: {
+        type: Boolean,
+      },
+    };
+  }
 
-    constructor() {
-        super();
-        this.endpoints = [];
-        this.label = 'dts.endpoint';
-    }
+  constructor() {
+    super();
+    this.endpoints = [];
+    this.label = 'dts.endpoint';
+  }
 
-    connectedCallback() {
-        super.connectedCallback();
-        this.endpoint = registry.state.endpoint;
-    }
+  connectedCallback() {
+    super.connectedCallback();
+    this.endpoint = registry.state.endpoint;
+  }
 
-    updated(changedProperties) {
-        super.updated();
-        if (changedProperties.has('endpoints')) {
-            const item = this.shadowRoot.getElementById('endpoints').selectedItem;
-            if (!item && this.auto && this.endpoints.length > 0) {
-                this.endpoint = this.endpoints[0].url;
-            }
-        }
+  updated(changedProperties) {
+    super.updated();
+    if (changedProperties.has('endpoints')) {
+      const item = this.shadowRoot.getElementById('endpoints').selectedItem;
+      if (!item && this.auto && this.endpoints.length > 0) {
+        this.endpoint = this.endpoints[0].url;
+      }
     }
+  }
 
-    render() {
-        return html`
-            <paper-dropdown-menu id="menu" label="${translate(this.label)}">
-                <paper-listbox id="endpoints" slot="dropdown-content" class="dropdown-content" selected="${this.endpoint}" attr-for-selected="value"
-                    @selected-item-changed="${this._selected}">
-                    ${this.endpoints.map((ep) => html`<paper-item value="${ep.url ? ep.url : ''}">${ep.title}</paper-item>`)}
-                </paper-listbox>
-            </paper-dropdown-menu>
-        `;
-    }
+  render() {
+    return html`
+      <paper-dropdown-menu id="menu" label="${translate(this.label)}">
+        <paper-listbox
+          id="endpoints"
+          slot="dropdown-content"
+          class="dropdown-content"
+          selected="${this.endpoint}"
+          attr-for-selected="value"
+          @selected-item-changed="${this._selected}"
+        >
+          ${this.endpoints.map(
+            ep => html`<paper-item value="${ep.url ? ep.url : ''}">${ep.title}</paper-item>`,
+          )}
+        </paper-listbox>
+      </paper-dropdown-menu>
+    `;
+  }
 
-    static get styles() {
-        return css`
-            :host {
-                display: block;
-            }
-        `;
-    }
+  static get styles() {
+    return css`
+      :host {
+        display: block;
+      }
+    `;
+  }
 
-    _selected() {
-        const item = this.shadowRoot.getElementById('endpoints').selectedItem;
-        if (!item) {
-            return;
-        }
-        const newEndpoint = item.getAttribute('value');
-        if (!newEndpoint) {
-            return;
-        }
-        const endpoint = this.endpoints.find((endp) => endp.url === newEndpoint);
-        registry.commit(this, { endpoint: endpoint.url });
-        console.log('<dts-select-endpoint> Setting endpoint to %s', newEndpoint);
-        this.emitTo('dts-endpoint', {
-            endpoint: endpoint.url,
-            collection: endpoint.collection,
-            reload: !this.endpoint
-        });
-        this.endpoint = endpoint.url;
+  _selected() {
+    const item = this.shadowRoot.getElementById('endpoints').selectedItem;
+    if (!item) {
+      return;
+    }
+    const newEndpoint = item.getAttribute('value');
+    if (!newEndpoint) {
+      return;
     }
+    const endpoint = this.endpoints.find(endp => endp.url === newEndpoint);
+    registry.commit(this, { endpoint: endpoint.url });
+    console.log('<dts-select-endpoint> Setting endpoint to %s', newEndpoint);
+    this.emitTo('dts-endpoint', {
+      endpoint: endpoint.url,
+      collection: endpoint.collection,
+      reload: !this.endpoint,
+    });
+    this.endpoint = endpoint.url;
+  }
 }
-customElements.define('dts-select-endpoint', DtsSelectEndpoint);
+customElements.define('dts-select-endpoint', DtsSelectEndpoint);

package/src/parse-date-service.js

@@ -1,29 +1,28 @@
 export class ParseDateService {
   /*
-  * PARSE DATE SERVICE
-  * whenever the user types a date, it should be allowed
-  * to type in a lot of dirrerent date formats. This service
-  * should detect all of the supported formats. Some supported formats:
-  * - 1. April 1970 => 1970-04-01
-  * - 1970          => 1970-01-01
-  * - 1970-12-23    => 1970-12-23
-  * - 1900 12 23    => 1900-12-23
-  * - 1 jan 1970    => 1970-01-01
-  * - 2020-W12      => 2020-03-16
-  * - 2020-01       => 2020-01-01
-  * For all formats check the tests written in AVA `test/parse-date-service-test.js`
-  *
-  * public methods
-  *   run()
-  */
-  constructor() {
-  }
+   * PARSE DATE SERVICE
+   * whenever the user types a date, it should be allowed
+   * to type in a lot of dirrerent date formats. This service
+   * should detect all of the supported formats. Some supported formats:
+   * - 1. April 1970 => 1970-04-01
+   * - 1970          => 1970-01-01
+   * - 1970-12-23    => 1970-12-23
+   * - 1900 12 23    => 1900-12-23
+   * - 1 jan 1970    => 1970-01-01
+   * - 2020-W12      => 2020-03-16
+   * - 2020-01       => 2020-01-01
+   * For all formats check the tests written in AVA `test/parse-date-service-test.js`
+   *
+   * public methods
+   *   run()
+   */
+  constructor() {}
 
-  run (input) {
+  run(input) {
     this.input = input;
-    this.day = "??";
-    this.month = "??";
-    this.year = "????";
+    this.day = '??';
+    this.month = '??';
+    this.year = '????';
 
     const resultIsoMatch = this.input.match(this._isoMatchRegex());
     const resultCustomMatch = this.input.match(this._customRegex());
@@ -31,14 +30,14 @@ export class ParseDateService {
     const resultYearAndMonthMatch = this.input.match(this._yearAndMonthRegex());
     if (resultIsoMatch) {
       const split = resultIsoMatch[1].split(/-|\/|\s/);
-      this.year  = split[0];
+      this.year = split[0];
       this.month = this._setWithLeadingZero(split[1]);
-      this.day   = this._setWithLeadingZero(split[2]);
+      this.day = this._setWithLeadingZero(split[2]);
     } else if (resultYearAndMonthMatch) {
-      const split = resultYearAndMonthMatch[1].split("-");
+      const split = resultYearAndMonthMatch[1].split('-');
       this.year = split[0];
       this.month = this._setWithLeadingZero(split[1]);
-      this.day = "01";
+      this.day = '01';
     } else if (resultCustomMatch) {
       const split = resultCustomMatch[0].split(/\.|\s|\/|-/);
       this.day = this._setWithLeadingZero(split[0]);
@@ -47,7 +46,7 @@ export class ParseDateService {
     } else if (resultWeekMatch) {
       const split = resultWeekMatch[0].split(/\.|\s|\/|-/);
       const year = Number(split[0]);
-      const week = Number(split[1].replace("W0", "").replace("W", ""));
+      const week = Number(split[1].replace('W0', '').replace('W', ''));
       return this._getDateStrOfISOWeek(year, week);
     } else {
       this._findYear();
@@ -58,65 +57,65 @@ export class ParseDateService {
   }
 
   _buildResult() {
-    if (this.year != "????" && this.month === "??") {
-      this.month = "01";
+    if (this.year != '????' && this.month === '??') {
+      this.month = '01';
     }
-    if (this.month != "??" && this.day === "??") {
-      this.day = "01";
+    if (this.month != '??' && this.day === '??') {
+      this.day = '01';
     }
     return `${this.year}-${this.month}-${this.day}`;
   }
 
   /*
-  * matches ISO string format (with some extensions)
-  * | 2012-01-31 | 2012-1-31 | 2012/01/31 |
-  * | 2012/1/31  | 2012 1 31 | 2012 01 31 |
-  */
+   * matches ISO string format (with some extensions)
+   * | 2012-01-31 | 2012-1-31 | 2012/01/31 |
+   * | 2012/1/31  | 2012 1 31 | 2012 01 31 |
+   */
   _isoMatchRegex() {
     return /(?:\s|^)(\d{4}(-|\s|\/)([0][1-9]|[1-9]|10|11|12)(-|\s|\/)([0][1-9]|[1-2][0-9]|3[01]|[1-9]))(?=\s|$|\.)/;
     /*      |        | year         | 01-09 | 1-9 | 10-12   |         |01-09  |10-29     |30,31| 1-9  |
-    *       |             | dash or slash                   | dash or slash                           |
-    *       |preceding with space or start of string                 end with space endofstr or dot <-|*/
+     *       |             | dash or slash                   | dash or slash                           |
+     *       |preceding with space or start of string                 end with space endofstr or dot <-| */
   }
 
   /*
-  * matches a custom date string format (reversed order, day-month-year)
-  * | 12.3.2000 | 1.2.2012 | 1-2-2012 |
-  * | 12/3/2000 | 1 2 2012 | 1/2/2012 |
-  */
+   * matches a custom date string format (reversed order, day-month-year)
+   * | 12.3.2000 | 1.2.2012 | 1-2-2012 |
+   * | 12/3/2000 | 1 2 2012 | 1/2/2012 |
+   */
   _customRegex() {
     return /\d{1,2}(\.|\s|\/|-)\d{1,2}(\.|\s|\/|-)\d{4}/;
     /*      | day  |           | month |          | year
-    *              |___________________|
-    *                        |
-    *        seperated by dot, space, slash or dash */
+     *              |___________________|
+     *                        |
+     *        seperated by dot, space, slash or dash */
   }
 
   /*
-  * matches a date format that specifies the week
-  * | 2012-W1 | 2012 W1  | 2012 W01 |
-  * | 2020.W2 | 2020-W53 | 2012/W1  |
-  */
+   * matches a date format that specifies the week
+   * | 2012-W1 | 2012 W1  | 2012 W01 |
+   * | 2020.W2 | 2020-W53 | 2012/W1  |
+   */
   _weekMatchRegex() {
     return /\d{4}(\.|\s|\/|-)W\d{1,2}(?=\s|$|\.)/;
     /*      |year |         |W1-W53   |
-    *             |___________________|
-    *                      |
-    *     seperated by dot, space, slash or dash */
+     *             |___________________|
+     *                      |
+     *     seperated by dot, space, slash or dash */
   }
 
   /*
-  * matches a date format with only year and month
-  * YYYY-MM (1-12)
-  * | 2020-01 | 2020-12 | 2012-1 |
-  */
+   * matches a date format with only year and month
+   * YYYY-MM (1-12)
+   * | 2020-01 | 2020-12 | 2012-1 |
+   */
   _yearAndMonthRegex() {
     return /(?:\s|^)(\d{4}-([0][1-9]|[1-9]|10|11|12))(?=\s|$)/;
   }
 
   _findYear() {
-    let regex = /[1-9]{1}[0-9]{3}/;
-    const result = this.input.match(regex)
+    const regex = /[1-9]{1}[0-9]{3}/;
+    const result = this.input.match(regex);
     if (result) {
       this.year = result[0];
       this._removeMatchFromInput(result);
@@ -126,9 +125,10 @@ export class ParseDateService {
   _findMonth() {
     const months = this._monthDictionaryValues();
     months.forEach(month => {
-      const re = new RegExp(`(?:\\s|^)(${month})(?=\\s|$|\\.)`, "i")
+      const re = new RegExp(`(?:\\s|^)(${month})(?=\\s|$|\\.)`, 'i');
       const result = this.input.match(re);
-      if (result) { // yes => get dict and value + return
+      if (result) {
+        // yes => get dict and value + return
         this.month = this._monthDictionary()[result[1].toLowerCase()];
         this._removeMatchFromInput(result);
         return this.month;
@@ -138,107 +138,155 @@ export class ParseDateService {
   }
 
   /*
-  * find single numbers from 1-31
-  */
+   * find single numbers from 1-31
+   */
   _findDay() {
     const regex = /(?:\s|^)([0][1-9]|[1-2][0-9]|3[01]|[1-9])(?=\s|$|\.|st|nd|rd|th)/;
     /*           |         | 01-09 | 10-29    |30,31|1-9    | ends with whitespace, endofstr or dot.
-    *            | starts with whitepace or startoftr       | won't be included in match (lookbehind operator)
-    *            | look behind operator (not included)
-    *            | https://stackoverflow.com/a/6713378/6272061 */
-    const result = this.input.match(regex)
+     *            | starts with whitepace or startoftr       | won't be included in match (lookbehind operator)
+     *            | look behind operator (not included)
+     *            | https://stackoverflow.com/a/6713378/6272061 */
+    const result = this.input.match(regex);
     if (result) {
       this.day = this._setWithLeadingZero(result[1]);
     }
   }
 
   /*
-  * if a string or number has only 1 digit or char
-  * a leading zro is added
-  * returns a string
-  */
+   * if a string or number has only 1 digit or char
+   * a leading zro is added
+   * returns a string
+   */
   _setWithLeadingZero(input) {
     input = input.toString();
     if (input.length == 1) {
-      return "0" + input;
-    } else {
-      return input;
+      return `0${input}`;
     }
+    return input;
   }
 
   _removeMatchFromInput(matchObj) {
     if (matchObj && matchObj[0] && matchObj.index) {
-      let len = matchObj[0].length;
-      let charArr = this.input.split('');
+      const len = matchObj[0].length;
+      const charArr = this.input.split('');
       charArr.splice(matchObj.index, len);
-      this.input = charArr.join("");
+      this.input = charArr.join('');
     }
   }
 
   _monthDictionaryValues() {
     return Object.keys(this._monthDictionary());
   }
+
   _monthDictionary() {
     return {
       // german
-      "jan": "01", "januar":    "01",
-      "feb": "02", "februar":   "02",
-      "mär": "03", "märz":      "03",
-      "apr": "04", "april":     "04",
-      "mai": "05", "mai":       "05",
-      "jun": "06", "juni":      "06",
-      "jul": "07", "juli":      "07",
-      "aug": "08", "august":    "08",
-      "sep": "09", "september": "09",
-      "okt": "10", "oktober":   "10",
-      "nov": "11", "november":  "11",
-      "dez": "12", "dezember":  "12",
+      jan: '01',
+      januar: '01',
+      feb: '02',
+      februar: '02',
+      mär: '03',
+      märz: '03',
+      apr: '04',
+      april: '04',
+      mai: '05',
+      mai: '05',
+      jun: '06',
+      juni: '06',
+      jul: '07',
+      juli: '07',
+      aug: '08',
+      august: '08',
+      sep: '09',
+      september: '09',
+      okt: '10',
+      oktober: '10',
+      nov: '11',
+      november: '11',
+      dez: '12',
+      dezember: '12',
       // english
-      "jan": "01", "january":   "01",
-      "feb": "02", "february":  "02",
-      "mar": "03", "march":     "03",
-      "apr": "04", "april":     "04",
-      "may": "05", "may":       "05",
-      "jun": "06", "june":      "06",
-      "jul": "07", "july":      "07",
-      "aug": "08", "august":    "08",
-      "sep": "09", "september": "09",
-      "oct": "10", "october":   "10",
-      "nov": "11", "november":  "11",
-      "dec": "12", "december":  "12",
+      jan: '01',
+      january: '01',
+      feb: '02',
+      february: '02',
+      mar: '03',
+      march: '03',
+      apr: '04',
+      april: '04',
+      may: '05',
+      may: '05',
+      jun: '06',
+      june: '06',
+      jul: '07',
+      july: '07',
+      aug: '08',
+      august: '08',
+      sep: '09',
+      september: '09',
+      oct: '10',
+      october: '10',
+      nov: '11',
+      november: '11',
+      dec: '12',
+      december: '12',
       // french
-      "janv":"01", "janvier":   "01",
-      "févr":"02", "février'":  "02",
-      "mars":"03", "mars":      "03",
-      "avr": "04", "avril":     "04",
-      "mai": "05", "mai":       "05",
-      "juin":"06", "juin":      "06",
-      "juil":"07", "juillet":   "07",
-      "août":"08", "août":      "08",
-      "sept":"09", "septembre": "09",
-      "oct": "10", "octobre":   "10",
-      "nov": "11", "novembre":  "11",
-      "déc": "12", "décembre":  "12",
-      //italian
-      "gen": "01", "gennaio":   "01",
-      "feb": "02", "febbraio":  "02",
-      "mar": "03", "marzo":     "03",
-      "apr": "04", "aprile":    "04",
-      "mag": "05", "maggio":    "05",
-      "giu": "06", "giugno":    "06",
-      "lug": "07", "luglio":    "07",
-      "ago": "08", "agosto":    "08",
-      "set": "09", "settembre": "09",
-      "ott": "10", "ottobre":   "10",
-      "nov": "11", "novembre":  "11",
-      "dic": "12", "dicembre":  "12",
-    }
+      janv: '01',
+      janvier: '01',
+      févr: '02',
+      "février'": '02',
+      mars: '03',
+      mars: '03',
+      avr: '04',
+      avril: '04',
+      mai: '05',
+      mai: '05',
+      juin: '06',
+      juin: '06',
+      juil: '07',
+      juillet: '07',
+      août: '08',
+      août: '08',
+      sept: '09',
+      septembre: '09',
+      oct: '10',
+      octobre: '10',
+      nov: '11',
+      novembre: '11',
+      déc: '12',
+      décembre: '12',
+      // italian
+      gen: '01',
+      gennaio: '01',
+      feb: '02',
+      febbraio: '02',
+      mar: '03',
+      marzo: '03',
+      apr: '04',
+      aprile: '04',
+      mag: '05',
+      maggio: '05',
+      giu: '06',
+      giugno: '06',
+      lug: '07',
+      luglio: '07',
+      ago: '08',
+      agosto: '08',
+      set: '09',
+      settembre: '09',
+      ott: '10',
+      ottobre: '10',
+      nov: '11',
+      novembre: '11',
+      dic: '12',
+      dicembre: '12',
+    };
   }
 
   _getDateStrOfISOWeek(y, w) {
-    let simple = new Date(y, 0, 1 + (w - 1) * 7);
-    let dow = simple.getDay();
-    let ISOweekStart = simple;
+    const simple = new Date(y, 0, 1 + (w - 1) * 7);
+    const dow = simple.getDay();
+    const ISOweekStart = simple;
     if (dow <= 4) {
       ISOweekStart.setDate(simple.getDate() - simple.getDay() + 1);
     } else {
@@ -247,20 +295,21 @@ export class ParseDateService {
     // do not rollover to next or previous year
     if (ISOweekStart.getFullYear() > y) {
       return `${y}-12-31`;
-    } else if (ISOweekStart.getFullYear() < y) {
+    }
+    if (ISOweekStart.getFullYear() < y) {
       return `${y}-01-01`;
     }
     return this._dateToDateStr(ISOweekStart);
   }
 
   /*
-  * formats date object to dateStr YYYY-MM-DD
-  */
+   * formats date object to dateStr YYYY-MM-DD
+   */
   _dateToDateStr(date) {
-    let d = new Date(date);
-    let month = this._setWithLeadingZero((d.getMonth() + 1));
-    let day = this._setWithLeadingZero(d.getDate());
-    let year = d.getFullYear();
+    const d = new Date(date);
+    const month = this._setWithLeadingZero(d.getMonth() + 1);
+    const day = this._setWithLeadingZero(d.getDate());
+    const year = d.getFullYear();
     return `${year}-${month}-${day}`;
   }
 }