@venite/components 0.16.7 → 0.16.13

package/dist/collection/components/editable-delete/editable-delete.js

@@ -0,0 +1,175 @@
+import { Component, Element, Prop, Listen, Event, State, h } from '@stencil/core';
+import { alertController } from '@ionic/core';
+import { Change } from '@venite/ldf';
+import { getComponentClosestLanguage } from '../../utils/locale';
+import EN from './editable-delete.i18n.en.json';
+const LOCALE = {
+  'en': EN
+};
+export class EditableDeleteComponent {
+  constructor() {
+    this.type = 'array';
+  }
+  // Listeners
+  async onClick() {
+    // show a confirmation alert
+    const alert = await alertController.create({
+      header: this.localeStrings.confirm_header,
+      message: this.localeStrings.confirm_message,
+      buttons: [
+        {
+          text: this.localeStrings.cancel,
+          role: 'cancel',
+          cssClass: 'secondary'
+        }, {
+          text: this.localeStrings.delete,
+          role: 'submit',
+          cssClass: 'danger',
+          handler: () => {
+            this.delete();
+          }
+        }
+      ]
+    });
+    // show the alert
+    return alert.present();
+  }
+  delete() {
+    if (this.type === 'array') {
+      this.ldfDocShouldChange.emit(new Change({
+        path: this.base,
+        op: [{ type: 'deleteAt', index: this.index, oldValue: this.obj }]
+      }));
+    }
+    else {
+      this.ldfDocShouldChange.emit(new Change({
+        path: this.base,
+        op: [{ type: 'delete', index: this.index, oldValue: this.obj }]
+      }));
+    }
+  }
+  // Lifecycle events
+  async componentWillLoad() {
+    this.loadLocaleStrings();
+  }
+  // Methods
+  async loadLocaleStrings() {
+    try {
+      this.localeStrings = LOCALE[getComponentClosestLanguage(this.element)];
+    }
+    catch (e) {
+      console.warn(e);
+    }
+  }
+  render() {
+    const localeStrings = this.localeStrings || {};
+    return (h("ion-buttons", null,
+      h("ion-button", { "aria-role": 'button', "aria-label": localeStrings.delete, size: 'small' },
+        h("ion-icon", { name: 'trash', slot: 'icon-only' }))));
+  }
+  static get is() { return "ldf-editable-delete"; }
+  static get encapsulation() { return "scoped"; }
+  static get properties() { return {
+    "base": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "A JSON Pointer that points to the array or object within which the item is nested"
+      },
+      "attribute": "base",
+      "reflect": true
+    },
+    "index": {
+      "type": "any",
+      "mutable": false,
+      "complexType": {
+        "original": "number | string",
+        "resolved": "number | string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "The item's index within that array, or property within that object"
+      },
+      "attribute": "index",
+      "reflect": true
+    },
+    "type": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "'array' | 'object'",
+        "resolved": "\"array\" | \"object\"",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "type",
+      "reflect": false,
+      "defaultValue": "'array'"
+    },
+    "obj": {
+      "type": "any",
+      "mutable": false,
+      "complexType": {
+        "original": "any",
+        "resolved": "any",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "The item to be deleted"
+      },
+      "attribute": "obj",
+      "reflect": false
+    }
+  }; }
+  static get states() { return {
+    "localeStrings": {}
+  }; }
+  static get events() { return [{
+      "method": "ldfDocShouldChange",
+      "name": "ldfDocShouldChange",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "Change",
+        "resolved": "Change",
+        "references": {
+          "Change": {
+            "location": "import",
+            "path": "@venite/ldf"
+          }
+        }
+      }
+    }]; }
+  static get elementRef() { return "element"; }
+  static get listeners() { return [{
+      "name": "click",
+      "method": "onClick",
+      "target": undefined,
+      "capture": false,
+      "passive": false
+    }]; }
+}

package/dist/collection/components/editable-filter-documents/dist/editable-filter-documents.js

@@ -0,0 +1,242 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+var __generator = (this && this.__generator) || function (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 };
+    }
+};
+exports.__esModule = true;
+exports.EditableFilterDocumentsComponent = void 0;
+var core_1 = require("@stencil/core");
+var ldf_1 = require("@venite/ldf");
+var locale_1 = require("../../utils/locale");
+var editable_filter_documents_i18n_en_json_1 = require("./editable-filter-documents.i18n.en.json");
+var LOCALE = {
+    'en': editable_filter_documents_i18n_en_json_1["default"]
+};
+var EditableFilterDocumentsComponent = /** @class */ (function () {
+    function EditableFilterDocumentsComponent() {
+        this.filteredOptions = [];
+        /** Whether to include a `LiturgicalDocument.version` field with the selection */
+        this.versions = {};
+        /** Options to search through */
+        this.options = [];
+    }
+    EditableFilterDocumentsComponent.prototype.versionChange = function () {
+        this.filter(this.search);
+    };
+    EditableFilterDocumentsComponent.prototype.versionsChange = function () {
+        if (!this.version) {
+            this.version = Object.keys(this.versions)[0];
+        }
+        this.filter(this.search);
+    };
+    EditableFilterDocumentsComponent.prototype.optionsChange = function () {
+        this.filter(this.search);
+    };
+    // Public Methods
+    /** Set the list of liturgy versions */
+    EditableFilterDocumentsComponent.prototype.setVersions = function (versions) {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                this.versions = __assign({}, versions);
+                return [2 /*return*/];
+            });
+        });
+    };
+    /** Set the list of liturgy versions */
+    EditableFilterDocumentsComponent.prototype.setOptions = function (options) {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                this.options = options;
+                this.optionsChange();
+                return [2 /*return*/];
+            });
+        });
+    };
+    // Lifecycle events
+    EditableFilterDocumentsComponent.prototype.componentWillLoad = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.loadLocaleStrings();
+                this.filteredOptions = this.options || [];
+                this.version = (this.versions || [])[0]; // default to first in list
+                this.filter(this.search);
+                return [2 /*return*/];
+            });
+        });
+    };
+    // Methods
+    EditableFilterDocumentsComponent.prototype.loadLocaleStrings = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                try {
+                    this.localeStrings = LOCALE[locale_1.getComponentClosestLanguage(this.element)];
+                }
+                catch (e) {
+                    console.warn(e);
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    EditableFilterDocumentsComponent.prototype.filter = function (search) {
+        var _this = this;
+        var _a;
+        this.search = search;
+        this.filteredOptions = (_a = this.options) === null || _a === void 0 ? void 0 : _a.filter(function (doc) {
+            var _a;
+            // version matches this.version, if set
+            return (_this.version ? doc.version == _this.version : true)
+                // search on label
+                && (search ? (_a = doc.label) === null || _a === void 0 ? void 0 : _a.match(search) : true);
+        });
+    };
+    EditableFilterDocumentsComponent.prototype.chooseVersion = function (version) {
+        this.version = version;
+    };
+    EditableFilterDocumentsComponent.prototype.chooseDoc = function (doc) {
+        this.doc = doc;
+    };
+    EditableFilterDocumentsComponent.prototype.choose = function () {
+        if (this.changeCallback) {
+            this.changeCallback(this.doc);
+        }
+        this.ldfDocumentSelected.emit(this.doc);
+        if (this.modal) {
+            this.modal.dismiss();
+        }
+    };
+    EditableFilterDocumentsComponent.prototype.render = function () {
+        var _this = this;
+        var localeStrings = this.localeStrings || {};
+        return (React.createElement(core_1.Host, null,
+            this.modal && React.createElement("ion-header", null,
+                React.createElement("ion-toolbar", null,
+                    React.createElement("ion-buttons", { slot: "end" },
+                        React.createElement("ion-button", { onClick: function () { return _this.modal.dismiss(); } },
+                            React.createElement("ion-icon", { name: "close", slot: "icon-only" }))))),
+            React.createElement("ion-content", null,
+                React.createElement("form", null,
+                    React.createElement("ion-list", null,
+                        React.createElement("ion-button", { fill: "clear", onClick: function () { _this.chooseDoc(ldf_1.docsToOption(_this.filteredOptions)); _this.choose(); } },
+                            React.createElement("ion-label", null, localeStrings.includeAll)),
+                        this.versions && React.createElement("ion-item", null,
+                            React.createElement("ion-label", null, localeStrings.version),
+                            React.createElement("ion-select", { value: this.version, onIonChange: function (ev) { return _this.chooseVersion(ev.detail.value); } }, Object.entries(this.versions)
+                                .sort(function (a, b) { return a[0] > b[0] ? 1 : -1; })
+                                .map(function (_a) {
+                                var versionKey = _a[0], versionLabel = _a[1];
+                                return React.createElement("ion-select-option", { value: versionKey }, versionLabel);
+                            }))),
+                        React.createElement("ion-searchbar", { onIonChange: function (ev) { return _this.filter(ev.detail.value); } }),
+                        this.filteredOptions && this.filteredOptions.map(function (doc) {
+                            var _a, _b, _c, _d;
+                            return React.createElement("ion-item", { button: true, onClick: function () { _this.chooseDoc(doc); _this.choose(); }, color: doc == _this.doc ? 'primary' : undefined }, (_b = (_a = doc.label) !== null && _a !== void 0 ? _a : doc.version_label) !== null && _b !== void 0 ? _b : "" + ((_d = (_c = (((doc.value || [])[0] || {}).text)) !== null && _c !== void 0 ? _c : (doc.value || [])[0]) !== null && _d !== void 0 ? _d : '') + (doc.citation ? " (" + doc.citation + ")" : ''));
+                        }))))));
+    };
+    __decorate([
+        core_1.Element()
+    ], EditableFilterDocumentsComponent.prototype, "element");
+    __decorate([
+        core_1.State()
+    ], EditableFilterDocumentsComponent.prototype, "localeStrings");
+    __decorate([
+        core_1.State()
+    ], EditableFilterDocumentsComponent.prototype, "filteredOptions");
+    __decorate([
+        core_1.State()
+    ], EditableFilterDocumentsComponent.prototype, "doc");
+    __decorate([
+        core_1.State()
+    ], EditableFilterDocumentsComponent.prototype, "version");
+    __decorate([
+        core_1.Watch('version')
+    ], EditableFilterDocumentsComponent.prototype, "versionChange");
+    __decorate([
+        core_1.Prop()
+    ], EditableFilterDocumentsComponent.prototype, "modal");
+    __decorate([
+        core_1.Prop()
+    ], EditableFilterDocumentsComponent.prototype, "type");
+    __decorate([
+        core_1.Prop()
+    ], EditableFilterDocumentsComponent.prototype, "versions");
+    __decorate([
+        core_1.Watch('versions')
+    ], EditableFilterDocumentsComponent.prototype, "versionsChange");
+    __decorate([
+        core_1.Prop()
+    ], EditableFilterDocumentsComponent.prototype, "options");
+    __decorate([
+        core_1.Watch('options')
+    ], EditableFilterDocumentsComponent.prototype, "optionsChange");
+    __decorate([
+        core_1.Prop()
+    ], EditableFilterDocumentsComponent.prototype, "changeCallback");
+    __decorate([
+        core_1.Event()
+    ], EditableFilterDocumentsComponent.prototype, "ldfDocumentSelected");
+    __decorate([
+        core_1.Method()
+    ], EditableFilterDocumentsComponent.prototype, "setVersions");
+    __decorate([
+        core_1.Method()
+    ], EditableFilterDocumentsComponent.prototype, "setOptions");
+    EditableFilterDocumentsComponent = __decorate([
+        core_1.Component({
+            tag: 'ldf-editable-filter-documents',
+            styleUrl: 'editable-filter-documents.scss',
+            scoped: true
+        })
+    ], EditableFilterDocumentsComponent);
+    return EditableFilterDocumentsComponent;
+}());
+exports.EditableFilterDocumentsComponent = EditableFilterDocumentsComponent;

package/dist/collection/components/editable-filter-documents/editable-filter-documents.css

@@ -0,0 +1,11 @@
+form {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+ion-button {
+  display: block;
+  margin: auto;
+  text-align: center;
+}

package/dist/collection/components/editable-filter-documents/editable-filter-documents.i18n.en.json

@@ -0,0 +1,9 @@
+{
+  "choose": "Choose a ",
+  "confirm": "Choose",
+  "includeAll": "Include all possibilities",
+  "version": "Version",
+  "psalm": "Psalm",
+  "collect": "Collect",
+  "reading": "Reading"
+}