@venite/components 0.16.48 → 0.16.49

package/dist/collection/components/parallel/dist/parallel.js

@@ -0,0 +1,146 @@
+"use strict";
+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.ParallelComponent = void 0;
+var core_1 = require("@stencil/core");
+var ldf_1 = require("@venite/ldf");
+var locale_1 = require("../../utils/locale");
+var parallel_i18n_en_json_1 = require("./parallel.i18n.en.json");
+var LOCALE = {
+    'en': parallel_i18n_en_json_1["default"]
+};
+var ParallelComponent = /** @class */ (function () {
+    function ParallelComponent() {
+    }
+    ParallelComponent.prototype.docChanged = function (newDoc) {
+        try {
+            if (typeof newDoc == 'string') {
+                this.obj = new ldf_1.Parallel(JSON.parse(newDoc));
+            }
+            else {
+                this.obj = new ldf_1.Parallel(newDoc);
+            }
+        }
+        catch (e) {
+            console.warn(e);
+            this.obj = new ldf_1.Parallel();
+        }
+    };
+    // Lifecycle events
+    ParallelComponent.prototype.componentWillLoad = function () {
+        this.docChanged(this.doc);
+        this.loadLocaleStrings();
+        this.ldfOptionAskForStoredSelection.emit({ el: this.el });
+    };
+    /** Asynchronously load localization strings */
+    ParallelComponent.prototype.loadLocaleStrings = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                try {
+                    this.localeStrings = LOCALE[locale_1.getComponentClosestLanguage(this.el)];
+                }
+                catch (e) {
+                    console.warn(e);
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    // Render
+    ParallelComponent.prototype.render = function () {
+        var _this = this;
+        var _a;
+        return (React.createElement(core_1.Host, { lang: this.obj.language },
+            React.createElement("tr", null, (((_a = this.obj) === null || _a === void 0 ? void 0 : _a.value) || []).map(function (obj, ii) { return React.createElement("td", null,
+                React.createElement("ldf-liturgical-document", { doc: obj, path: _this.path + "/value/" + ii, base: _this.path + "/value", index: ii, editable: _this.editable, parentType: 'option' })); }))));
+    };
+    __decorate([
+        core_1.Element()
+    ], ParallelComponent.prototype, "el");
+    __decorate([
+        core_1.State()
+    ], ParallelComponent.prototype, "obj");
+    __decorate([
+        core_1.State()
+    ], ParallelComponent.prototype, "localeStrings");
+    __decorate([
+        core_1.State()
+    ], ParallelComponent.prototype, "filteredOptions");
+    __decorate([
+        core_1.Prop()
+    ], ParallelComponent.prototype, "doc");
+    __decorate([
+        core_1.Watch('doc')
+    ], ParallelComponent.prototype, "docChanged");
+    __decorate([
+        core_1.Prop({ reflect: true })
+    ], ParallelComponent.prototype, "path");
+    __decorate([
+        core_1.Prop()
+    ], ParallelComponent.prototype, "editable");
+    __decorate([
+        core_1.Prop()
+    ], ParallelComponent.prototype, "preview");
+    __decorate([
+        core_1.Event({ bubbles: true })
+    ], ParallelComponent.prototype, "ldfAddOptionToDoc");
+    __decorate([
+        core_1.Event({ bubbles: true })
+    ], ParallelComponent.prototype, "ldfDocShouldChange");
+    __decorate([
+        core_1.Event({ bubbles: true })
+    ], ParallelComponent.prototype, "ldfOptionAskForStoredSelection");
+    __decorate([
+        core_1.Event({ bubbles: true })
+    ], ParallelComponent.prototype, "ldfOptionMakeSelection");
+    ParallelComponent = __decorate([
+        core_1.Component({
+            tag: 'ldf-parallel',
+            styleUrl: 'parallel.scss',
+            scoped: true
+        })
+    ], ParallelComponent);
+    return ParallelComponent;
+}());
+exports.ParallelComponent = ParallelComponent;

package/dist/collection/components/parallel/parallel.css

@@ -0,0 +1,8 @@
+.select-control {
+  margin-top: var(--ldf-select-control-margin-top);
+}
+
+ion-select {
+  width: 75vw;
+  max-width: 300px;
+}

package/dist/collection/components/parallel/parallel.i18n.en.json

@@ -0,0 +1,3 @@
+{
+  "parallel": "Parallel"
+}

package/dist/collection/components/parallel/parallel.js

@@ -0,0 +1,213 @@
+import { Component, Prop, Watch, State, Host, Event, Element, h } from '@stencil/core';
+import { Parallel } from '@venite/ldf';
+import { getComponentClosestLanguage } from '../../utils/locale';
+import EN from './parallel.i18n.en.json';
+const LOCALE = {
+  'en': EN
+};
+export class ParallelComponent {
+  docChanged(newDoc) {
+    try {
+      if (typeof newDoc == 'string') {
+        this.obj = new Parallel(JSON.parse(newDoc));
+      }
+      else {
+        this.obj = new Parallel(newDoc);
+      }
+    }
+    catch (e) {
+      console.warn(e);
+      this.obj = new Parallel();
+    }
+  }
+  // Lifecycle events
+  componentWillLoad() {
+    this.docChanged(this.doc);
+    this.loadLocaleStrings();
+    this.ldfOptionAskForStoredSelection.emit({ el: this.el });
+  }
+  /** Asynchronously load localization strings */
+  async loadLocaleStrings() {
+    try {
+      this.localeStrings = LOCALE[getComponentClosestLanguage(this.el)];
+    }
+    catch (e) {
+      console.warn(e);
+    }
+  }
+  // Render
+  render() {
+    var _a;
+    return (h(Host, { lang: this.obj.language },
+      h("tr", null, (((_a = this.obj) === null || _a === void 0 ? void 0 : _a.value) || []).map((obj, ii) => h("td", null,
+        h("ldf-liturgical-document", { doc: obj, path: `${this.path}/value/${ii}`, base: `${this.path}/value`, index: ii, editable: this.editable, parentType: 'option' }))))));
+  }
+  static get is() { return "ldf-parallel"; }
+  static get encapsulation() { return "scoped"; }
+  static get originalStyleUrls() { return {
+    "$": ["parallel.scss"]
+  }; }
+  static get styleUrls() { return {
+    "$": ["parallel.css"]
+  }; }
+  static get properties() { return {
+    "doc": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "Parallel | string",
+        "resolved": "Parallel | string",
+        "references": {
+          "Parallel": {
+            "location": "import",
+            "path": "@venite/ldf"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "An LDF Option object."
+      },
+      "attribute": "doc",
+      "reflect": false
+    },
+    "path": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "A JSON Pointer that points to the Option being edited"
+      },
+      "attribute": "path",
+      "reflect": true
+    },
+    "editable": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Whether the object is editable"
+      },
+      "attribute": "editable",
+      "reflect": false
+    },
+    "preview": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Whether the object is in preview mode"
+      },
+      "attribute": "preview",
+      "reflect": false
+    }
+  }; }
+  static get states() { return {
+    "obj": {},
+    "localeStrings": {},
+    "filteredOptions": {}
+  }; }
+  static get events() { return [{
+      "method": "ldfAddOptionToDoc",
+      "name": "ldfAddOptionToDoc",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "AddOptionToDoc",
+        "resolved": "AddOptionToDoc",
+        "references": {
+          "AddOptionToDoc": {
+            "location": "import",
+            "path": "../../interfaces/add-option-to-doc"
+          }
+        }
+      }
+    }, {
+      "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"
+          }
+        }
+      }
+    }, {
+      "method": "ldfOptionAskForStoredSelection",
+      "name": "ldfOptionAskForStoredSelection",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "{ el: HTMLElement }",
+        "resolved": "{ el: HTMLElement; }",
+        "references": {
+          "HTMLElement": {
+            "location": "global"
+          }
+        }
+      }
+    }, {
+      "method": "ldfOptionMakeSelection",
+      "name": "ldfOptionMakeSelection",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "{ slug: string; index: number; }",
+        "resolved": "{ slug: string; index: number; }",
+        "references": {}
+      }
+    }]; }
+  static get elementRef() { return "el"; }
+  static get watchers() { return [{
+      "propName": "doc",
+      "methodName": "docChanged"
+    }]; }
+}

package/dist/collection/i18n/parallel.i18n.en.json

@@ -0,0 +1,3 @@
+{
+  "parallel": "Parallel"
+}

package/dist/esm/index-034add74.js

@@ -2066,10 +2066,10 @@ const loadModule = (cmpMeta, hostRef, hmrVersionId) => {
           return import(
             /* webpackMode: "lazy" */
             './ldf-editable-string-list.entry.js').then(processMod, consoleError);
-        case 'ion-segment_16':
+        case 'ion-segment_17':
           return import(
             /* webpackMode: "lazy" */
-            './ion-segment_16.entry.js').then(processMod, consoleError);
+            './ion-segment_17.entry.js').then(processMod, consoleError);
         case 'ldf-editable-boolean_2':
           return import(
             /* webpackMode: "lazy" */