@pacem/pacem-cms 1.0.0-abel

package/dist/bundle/pacem-cms.mjs

@@ -0,0 +1,2269 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/cms/dist/esm/index.components.js
+var index_components_exports = {};
+__export(index_components_exports, {
+  ACCESS_TOKEN_METADATA: () => ACCESS_TOKEN_METADATA,
+  DATACOLUMNS_METADATA_TYPE: () => DATACOLUMNS_METADATA_TYPE,
+  DEFAULT_METADATA: () => DEFAULT_METADATA,
+  EXPRESSION_METADATA_TYPE: () => EXPRESSION_METADATA_TYPE,
+  EXPRESSION_WIDGET_METADATA_EXTRA: () => EXPRESSION_WIDGET_METADATA_EXTRA,
+  ExpressionSource: () => ExpressionSource,
+  FETCH_CREDENTIALS_METADATA: () => FETCH_CREDENTIALS_METADATA,
+  Functions: () => Functions,
+  GRID_COLUMNS: () => GRID_COLUMNS,
+  LayoutChangeEventName: () => LayoutChangeEventName,
+  PacemBearerWidgetElement: () => PacemBearerWidgetElement,
+  PacemCompositeWidgetElement: () => PacemCompositeWidgetElement,
+  PacemDataColumnElement: () => PacemDataColumnElement,
+  PacemDataColumnsElement: () => PacemDataColumnsElement,
+  PacemElementPickerElement: () => PacemElementPickerElement,
+  PacemElementPickerElementBase: () => PacemElementPickerElementBase,
+  PacemExpressionElement: () => PacemExpressionElement,
+  PacemGridWidgetElement: () => PacemGridWidgetElement,
+  PacemUiWidgetElement: () => PacemUiWidgetElement,
+  PacemWidgetApiManifestElement: () => PacemWidgetApiManifestElement,
+  PacemWidgetClockElement: () => PacemWidgetClockElement,
+  PacemWidgetDataElement: () => PacemWidgetDataElement,
+  PacemWidgetDataGridElement: () => PacemWidgetDataGridElement,
+  PacemWidgetElement: () => PacemWidgetElement,
+  PacemWidgetFetchElement: () => PacemWidgetFetchElement,
+  PacemWidgetFetchParameterElement: () => PacemWidgetFetchParameterElement,
+  PacemWidgetPickerElement: () => PacemWidgetPickerElement,
+  PacemWidgetTextElement: () => PacemWidgetTextElement,
+  PacemWidgetToolbarElement: () => PacemWidgetToolbarElement,
+  PacemWidgetTranslatorElement: () => PacemWidgetTranslatorElement,
+  Widget: () => Widget,
+  WidgetRegisterEvent: () => WidgetRegisterEvent,
+  WidgetRegisterEventName: () => WidgetRegisterEventName,
+  WidgetUnregisterEvent: () => WidgetUnregisterEvent,
+  WidgetUnregisterEventName: () => WidgetUnregisterEventName,
+  buildWidgetMetadata: () => buildWidgetMetadata,
+  gridifyMetadata: () => gridifyMetadata
+});
+
+// packages/cms/dist/esm/scaffolding/types.js
+import { PropertyChangeEventName, Utils, CustomElementUtils, P } from "@pacem/pacem-core";
+var Functions = {
+  "dismiss": (...args) => {
+    for (let name of args || []) {
+      delete Functions[name];
+    }
+  },
+  "handleExpressionValueChange": (evt, prop, entity) => {
+    if (evt.detail.propertyName === "value" && !Utils.isNull(entity)) {
+      const value = evt.detail.currentValue;
+      if (entity instanceof HTMLElement) {
+        let attr = CustomElementUtils.camelToKebab(prop);
+        if (Utils.isNullOrEmpty(value)) {
+          entity.removeAttribute(attr);
+        } else {
+          entity.setAttribute(attr, value.toString());
+        }
+      } else {
+        entity[prop] = value;
+      }
+    }
+  }
+};
+var EXPRESSION_METADATA_TYPE = (host, hostRef = ":host", hostEntityRef = ":host.entity") => {
+  const attrs = {}, meta = host.metadata, fns = Functions, fnKeys = [];
+  attrs["value"] = `{{ ${hostEntityRef} instanceof HTMLElement && ${hostEntityRef}.getAttribute('${CustomElementUtils.camelToKebab(meta.prop)}') }}`;
+  attrs["on-" + PropertyChangeEventName] = `Pacem.Components.Cms.Functions.handleExpressionValueChange($event, '${meta.prop}', ${hostEntityRef})`;
+  attrs["converter"] = `{{ Pacem.CustomElementUtils.getWatchedProperty(${hostEntityRef}, '${meta.prop}').config.converter }}`;
+  const tagName = P + "-expression";
+  let extra = meta.extra || {};
+  if (!Utils.isNullOrEmpty(extra.selector)) {
+    attrs["selector"] = extra.selector;
+  }
+  if (!Utils.isNullOrEmpty(extra.filter)) {
+    switch (typeof extra.filter) {
+      case "string":
+        attrs["filter"] = `{{ (e) => e.constructor.name === "${extra.filter}" || e.localName === "${extra.filter.toLowerCase()}" }}`;
+        break;
+      case "function":
+        const fnKey = "fn" + Utils.uniqueCode();
+        fns[fnKey] = extra.filter;
+        attrs["filter"] = `{{ Pacem.Components.Cms.Functions.${fnKey}, once }}`;
+        fnKeys.push(fnKey);
+        break;
+    }
+  }
+  if (typeof extra.labeler === "function") {
+    const fnKey = "fn" + Utils.uniqueCode();
+    fns[fnKey] = extra.labeler;
+    attrs["labeler"] = `{{ Pacem.Components.Cms.Functions.${fnKey}, once }}`;
+    fnKeys.push(fnKey);
+  }
+  if (fnKeys.length > 0) {
+    attrs["on-unload"] = `{{ Pacem.Components.Cms.Functions.dismiss('${fnKeys.join("','")}') }}`;
+  }
+  return { tagName, attrs };
+};
+
+// packages/cms/dist/esm/scaffolding/element-picker.js
+import { CustomElement, P as P2, Defaults, Watch, PropertyConverters, ViewChild, Debounce, Utils as Utils2 } from "@pacem/pacem-core";
+import { Components as ScaffoldingComponents } from "@pacem/pacem-scaffolding";
+var __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 PacemElementPickerElementBase = class extends ScaffoldingComponents.Scaffolding.PacemBaseElement {
+};
+__decorate([
+  Watch({ converter: PropertyConverters.String })
+], PacemElementPickerElementBase.prototype, "selector", void 0);
+__decorate([
+  Watch({ converter: PropertyConverters.Eval })
+], PacemElementPickerElementBase.prototype, "filter", void 0);
+__decorate([
+  Watch({ converter: PropertyConverters.Eval })
+], PacemElementPickerElementBase.prototype, "labeler", void 0);
+var PacemElementPickerElement = class PacemElementPickerElement2 extends PacemElementPickerElementBase {
+  get inputFields() {
+    return [this._select];
+  }
+  toggleReadonlyView(readonly) {
+    this._select.readonly = readonly;
+  }
+  onChange(_) {
+    return Utils2.fromResult(this.value = this._select.value);
+  }
+  acceptValue(val) {
+    this._select.value = val;
+  }
+  getViewValue(value) {
+    return this._select.viewValue;
+  }
+  convertValueAttributeToProperty(attr) {
+    return PropertyConverters.Element.convert(attr);
+  }
+  viewActivatedCallback() {
+    super.viewActivatedCallback();
+    this._databind();
+  }
+  propertyChangedCallback(name, old, val, first) {
+    super.propertyChangedCallback(name, old, val, first);
+    if (!first) {
+      switch (name) {
+        case "selector":
+        case "filter":
+        case "labeler":
+          this._databind();
+          break;
+      }
+    }
+  }
+  _databind() {
+    const project = this.labeler || ((e) => {
+      let label = e.constructor.name;
+      if (e.id) {
+        label += "#" + e.id;
+      }
+      return label;
+    });
+    const retval = [];
+    document.querySelectorAll(this.selector || "[pacem]").forEach((e, i, arr) => {
+      if ((Utils2.isNull(this.filter) || this.filter(e) === true) && !Utils2.isNullOrEmpty(e.id)) {
+        retval.push({ element: e, label: project(e) });
+      }
+    });
+    this._select.valueProperty = "element";
+    this._select.textProperty = "label";
+    this._select.datasource = retval;
+  }
+};
+__decorate([
+  ViewChild(P2 + "-select")
+], PacemElementPickerElement.prototype, "_select", void 0);
+__decorate([
+  Debounce(50)
+], PacemElementPickerElement.prototype, "_databind", null);
+PacemElementPickerElement = __decorate([
+  CustomElement({
+    tagName: P2 + "-element-picker",
+    shadow: Defaults.USE_SHADOW_ROOT,
+    template: `<${P2}-select></${P2}-select>`
+  })
+], PacemElementPickerElement);
+
+// packages/cms/dist/esm/scaffolding/expression.js
+import { CustomElement as CustomElement2, P as P3, PCSS, Defaults as Defaults2, Watch as Watch2, PropertyConverters as PropertyConverters2, ViewChild as ViewChild2, Debounce as Debounce2, Utils as Utils3, CustomElementUtils as CustomElementUtils2, RepeaterItem } from "@pacem/pacem-core";
+import { Components as ScaffoldingComponents2 } from "@pacem/pacem-scaffolding";
+var __decorate2 = 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 ExpressionSource;
+(function(ExpressionSource2) {
+  ExpressionSource2["Constant"] = "const";
+  ExpressionSource2["PropertyReference"] = "property";
+  ExpressionSource2["Expression"] = "expr";
+})(ExpressionSource || (ExpressionSource = {}));
+var PacemExpressionElement = class PacemExpressionElement2 extends PacemElementPickerElementBase {
+  propertyChangedCallback(name, old, val, first) {
+    super.propertyChangedCallback(name, old, val, first);
+    if (name === "converter") {
+      this._setFeedbackText(this.value);
+    } else if (!first) {
+      if (this._editing) {
+        switch (name) {
+          case "_source":
+            switch (val) {
+              case ExpressionSource.PropertyReference:
+                this._picker.focus();
+                break;
+              default:
+                this._editor.focus();
+                break;
+            }
+            break;
+          case "_propRef":
+            if (!Utils3.isNullOrEmpty(val)) {
+              this._editor.focus();
+              this._editor.value = "{{ #" + this._sourceRef.id + "." + val + "  }}";
+            }
+            this.changeHandler(new Event("change"));
+            break;
+        }
+      }
+    }
+  }
+  get inputFields() {
+    return [this._editor];
+  }
+  toggleReadonlyView(readonly) {
+    if (readonly) {
+      this._editing = false;
+    }
+  }
+  setPristine() {
+    super.setPristine();
+    this._editing = false;
+  }
+  onChange(_) {
+    return Utils3.fromResult(this.value = this._editor.value);
+  }
+  acceptValue(val) {
+    this._view.textContent = val || "...";
+    this._setFeedbackText(val);
+    this._reverseStructure();
+    if (val !== this._editor.value) {
+      this._editor.value = val;
+    }
+  }
+  _setFeedbackText(val = this.value) {
+    const converter = this.converter;
+    if (CustomElementUtils2.isBindingAttribute(val) || typeof (converter && converter.convert) !== "function") {
+      this._eval.setAttribute("text", val);
+    } else if (val === void 0) {
+      this._eval.text = "<undefined>";
+    } else {
+      this._eval.text = converter.convert(val);
+    }
+  }
+  getViewValue(value) {
+    return value;
+  }
+  convertValueAttributeToProperty(attr) {
+    return attr;
+  }
+  _reverseStructure() {
+    let cleanup = () => {
+      this._source = this._sourceRef = this._propRef = /*this.value =*/
+      void 0;
+    };
+    let expr = this.value;
+    if (!Utils3.isNullOrEmpty(expr)) {
+      if (CustomElementUtils2.isBindingAttribute(expr)) {
+        const expression = CustomElementUtils2.parseBindingAttribute(expr, this), deps = expression.dependencies;
+        if (Utils3.isNullOrEmpty(deps) || deps.length > 1 || RepeaterItem.isRepeaterItem(deps[0].element)) {
+          this._source = ExpressionSource.Expression;
+        } else {
+          const dep = deps[0];
+          this._source = ExpressionSource.PropertyReference;
+          this._sourceRef = document.querySelector("#" + dep.element.id);
+          this._propRef = dep.path;
+        }
+      } else {
+        this._source = ExpressionSource.Constant;
+      }
+    } else {
+      cleanup();
+    }
+  }
+};
+__decorate2([
+  Watch2({ emit: false })
+], PacemExpressionElement.prototype, "converter", void 0);
+__decorate2([
+  Watch2({ converter: PropertyConverters2.Boolean })
+], PacemExpressionElement.prototype, "_editing", void 0);
+__decorate2([
+  Watch2({ converter: PropertyConverters2.String })
+], PacemExpressionElement.prototype, "_source", void 0);
+__decorate2([
+  Watch2({ converter: PropertyConverters2.Element })
+], PacemExpressionElement.prototype, "_sourceRef", void 0);
+__decorate2([
+  Watch2({ converter: PropertyConverters2.String })
+], PacemExpressionElement.prototype, "_propRef", void 0);
+__decorate2([
+  ViewChild2(P3 + "-element-picker")
+], PacemExpressionElement.prototype, "_picker", void 0);
+__decorate2([
+  ViewChild2(P3 + "-textarea")
+], PacemExpressionElement.prototype, "_editor", void 0);
+__decorate2([
+  ViewChild2("span." + PCSS + "-viewfinder")
+], PacemExpressionElement.prototype, "_view", void 0);
+__decorate2([
+  ViewChild2(P3 + "-text")
+], PacemExpressionElement.prototype, "_eval", void 0);
+__decorate2([
+  Debounce2(50)
+], PacemExpressionElement.prototype, "_reverseStructure", null);
+PacemExpressionElement = __decorate2([
+  CustomElement2({
+    tagName: P3 + "-expression",
+    shadow: Defaults2.USE_SHADOW_ROOT,
+    template: `<${P3}-collapse class="${PCSS}-expression" collapse="{{ !:host._editing }}">
+    <div class="expression-builder ${PCSS}-grid grid-tiny-rowgap grid-tiny-colgap ${PCSS}-pad pad-bottom-2">
+        <div class="${PCSS}-cell">
+            <${P3}-select value="{{ :host._source, twoway }}" class="display-block">
+                <${P3}-data-item value="${ExpressionSource.Constant}" label="constant value"></${P3}-data-item>
+                <${P3}-data-item value="${ExpressionSource.PropertyReference}" label="property reference"></${P3}-data-item>
+                <${P3}-data-item value="${ExpressionSource.Expression}" label="complex expression"></${P3}-data-item>
+            </${P3}-select>
+        </div>
+
+        <${P3}-panel class="${PCSS}-cell cols-hd-6" hide="{{ :host._source !== '${ExpressionSource.PropertyReference}' }}">
+            <${P3}-element-picker value="{{ :host._sourceRef, twoway }}" selector="{{ :host.selector }}" filter="{{ :host.filter }}" labeler="{{ :host.labeler }}" class="display-block"></${P3}-element-picker>
+        </${P3}-panel>
+        <${P3}-panel class="${PCSS}-cell cols-hd-6" hide="{{ :host._source !== '${ExpressionSource.PropertyReference}' }}">
+            <${P3}-property-picker value="{{ :host._propRef, twoway }}" disabled="{{ !:host._sourceRef }}" target="{{ :host._sourceRef }}" on-change="::_editor.focus()" class="display-block"></${P3}-property-picker>
+        </${P3}-panel>
+
+        <${P3}-panel class="${PCSS}-cell">
+            <${P3}-textarea class="display-block" placeholder="{{ '{{ '+ (:host._source || '') +'... }}' }}" change-policy="${ScaffoldingComponents2.Scaffolding.ChangePolicy.Blur}"></${P3}-textarea>
+        </${P3}-panel>
+    </div>
+</${P3}-collapse>
+<div class="${PCSS}-fieldset">
+    <div class="fieldset-left">
+        <div class="${PCSS}-fieldgroup ${PCSS}-viewfinder">
+            <div class="text-truncate ${PCSS}-pad pad-x-1"><span class="${PCSS}-viewfinder text-tech">{{ :host.value || '...' }}</span></div>
+            <${P3}-panel class="fieldgroup-prepend">
+                <${P3}-button class="flat edit ${PCSS}-pad pad-left-1" on-click=":host._editing = !:host._editing" hide="{{ :host.readonly }}"></${P3}-button>
+            </${P3}-panel>
+            <${P3}-panel class="fieldgroup-append text-tech display-flex flex-middle flex-nowrap" hide="{{ $pacem.isNullOrEmpty(:host.value) }}">
+                <i class="${PCSS}-icon text-primary">keyboard_arrow_right</i>
+                <${P3}-text text="?" class="bg-primary ${PCSS}-pad pad-left-1 pad-right-1 ${PCSS}-margin margin-right-1 text-truncate" eval></${P3}-text>
+            </${P3}-panel>
+        </div>
+    </div>
+</div>`
+  })
+], PacemExpressionElement);
+
+// packages/cms/dist/esm/widgets/types.js
+import { CustomElement as CustomElement3, P as P4, PCSS as PCSS2, Defaults as Defaults3, Watch as Watch3, PropertyConverters as PropertyConverters3, ViewChild as ViewChild3, Utils as Utils4, CustomElementUtils as CustomElementUtils3, Components } from "@pacem/pacem-core";
+import { Components as UIComponents } from "@pacem/pacem-ui";
+var __decorate3 = 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 UI = UIComponents.UI;
+var DEFAULT_PERMISSION_METADATA = {
+  props: [
+    {
+      prop: "permissions",
+      // child form-fields
+      type: "array",
+      display: { name: "Permissions" },
+      props: {
+        display: { cssClass: [PCSS2 + "-cell", PCSS2 + "-grid", "grid-novgap", "grid-tiny-colgap", "grid-nospace"], name: "Permission" },
+        props: Array.prototype.concat.apply([
+          {
+            prop: "claimType",
+            type: "string",
+            display: { cssClass: [PCSS2 + "-cell", "cols-hd-4", "cols-lg-6", "field-stretch", "field-minimal"], name: "Claim type" },
+            validators: [{ type: "required", errorMessage: "!" }]
+          },
+          {
+            prop: "claimValue",
+            type: "string",
+            display: { cssClass: [PCSS2 + "-cell", "cols-hd-4", "cols-lg-6", "field-stretch", "field-minimal"], name: "Claim value" },
+            validators: [{ type: "required", errorMessage: "!" }]
+          }
+        ], ["read", "update", "create", "delete"].map((p, j) => {
+          return {
+            prop: p,
+            type: "boolean",
+            display: { cssClass: [PCSS2 + "-cell", "cols-hd-1", "cols-3", "field-minimal", PCSS2 + "-pad pad-left-2"], name: p.charAt(0).toUpperCase() + p.substr(1) }
+          };
+        }))
+      }
+    }
+  ]
+};
+var DEFAULT_METADATA = {
+  display: { name: "Widget", cssClass: [PCSS2 + "-grid", "grid-novgap", "grid-tiny-colgap", "grid-nospace"] },
+  props: [
+    { prop: "tag", type: "string", display: { name: "Tag", cssClass: [PCSS2 + "-cell"] } }
+  ]
+};
+function cellifyMetadata(p) {
+  p.display = p.display || { name: p.prop, cssClass: [] };
+  const css = p.display.cssClass = Utils4.isArray(p.display.cssClass) && p.display.cssClass || [];
+  css.push(PCSS2 + "-cell");
+}
+function gridifyMetadata(metadata) {
+  var props = metadata && metadata.props || [];
+  var display = metadata && metadata.display || { name: "Element" };
+  if (!Utils4.isNull(display)) {
+    const css = display.cssClass = display.cssClass || [];
+    Array.prototype.push.apply(css, DEFAULT_METADATA.display.cssClass);
+  }
+  props.forEach(cellifyMetadata);
+  return { display, props };
+}
+function buildWidgetMetadata(metadata) {
+  var display = Utils4.extend({}, DEFAULT_METADATA.display, metadata && metadata.display || {});
+  var props = Utils4.clone(DEFAULT_METADATA.props);
+  Array.prototype.push.apply(props, (metadata && metadata.props || []).filter((p) => {
+    if (p.prop === "tag") {
+      return false;
+    }
+    cellifyMetadata(p);
+    return true;
+  }));
+  return { display, props };
+}
+var WIDGET_CSS_CLASS = PCSS2 + "-widget";
+var EXPRESSION_WIDGET_METADATA_EXTRA = {
+  selector: "." + WIDGET_CSS_CLASS,
+  labeler: (e) => {
+    if (!Utils4.isNullOrEmpty(e.tag)) {
+      return e.tag;
+    }
+    return (e.metadata && e.metadata.display && e.metadata.display.name || "") + "#" + e.id;
+  }
+};
+var Widget = class {
+  /**
+   * Utility method for widget gathering.
+   * @param predicate Predicate for filtering
+   */
+  static findAll(predicate) {
+    return CustomElementUtils3.findAll("." + WIDGET_CSS_CLASS, (widget) => widget instanceof PacemWidgetElement && !Utils4.isNullOrEmpty(widget.id) && (Utils4.isNull(predicate) || predicate(widget)));
+  }
+};
+var PacemWidgetToolbarElement = class PacemWidgetToolbarElement2 extends Components.PacemElement {
+  /** Gets the toolbar's edit button. */
+  get editButton() {
+    return this._btnEdit;
+  }
+  /** Gets the toolbar's permimssions button. */
+  get permissionsButton() {
+    return this._btnPerms;
+  }
+  /** Gets the toolbar's remove button. */
+  get removeButton() {
+    return this._btnRemove;
+  }
+  _edit(evt) {
+    const form = this._proxy.dom.find((e) => "core" in e.attributes);
+    form.open(this.target, true);
+    form.metadata = this.target.metadata;
+    this._popoutJustInCase();
+  }
+  _editPermissions(evt) {
+    const form = this._proxy.dom.find((e) => "permissions" in e.attributes);
+    form.open(this.target);
+    form.metadata = this.target.permissionMetadata;
+    this._popoutJustInCase();
+  }
+  _popoutJustInCase() {
+    const balloon = CustomElementUtils3.findAncestorOfType(this, UI.PacemBalloonElement);
+    if (!Utils4.isNullOrEmpty(balloon)) {
+      balloon.popout();
+    }
+  }
+};
+__decorate3([
+  Watch3({ emit: false, converter: PropertyConverters3.Element })
+], PacemWidgetToolbarElement.prototype, "target", void 0);
+__decorate3([
+  ViewChild3(".buttons > div")
+], PacemWidgetToolbarElement.prototype, "_toolbar", void 0);
+__decorate3([
+  ViewChild3(P4 + "-button[edit]")
+], PacemWidgetToolbarElement.prototype, "_btnEdit", void 0);
+__decorate3([
+  ViewChild3(P4 + "-button[permissions]")
+], PacemWidgetToolbarElement.prototype, "_btnPerms", void 0);
+__decorate3([
+  ViewChild3(P4 + "-button[remove]")
+], PacemWidgetToolbarElement.prototype, "_btnRemove", void 0);
+__decorate3([
+  ViewChild3(P4 + "-shell-proxy")
+], PacemWidgetToolbarElement.prototype, "_proxy", void 0);
+PacemWidgetToolbarElement = __decorate3([
+  CustomElement3({
+    tagName: P4 + "-widget-toolbar",
+    shadow: Defaults3.USE_SHADOW_ROOT,
+    template: `<${P4}-span class="toolbar-text" content="{{ '<i class=&quot;${PCSS2}-icon&quot;>'+ (::target.metadata && ::target.metadata.display && ::target.metadata.display.icon || 'widgets') +'</i> '+ (::target.tag || (::target.metadata && ::target.metadata.display && ::target.metadata.display.name || ::target.localName) +'#'+ ::target.id) }}"></${P4}-span>
+<div class="buttons ${PCSS2}-buttonset ${PCSS2}-pad ${PCSS2}-margin pad-0 margin-left-2">
+    <div class="buttonset-left">
+        <${P4}-button edit class="button edit" on-click=":host._edit($event)"></${P4}-button>
+        <${P4}-button permissions class="button" on-click=":host._editPermissions($event)" css-class="{{ {'button-success': ::target.permissions.length > 0} }}" icon-glyph="verified_user"></${P4}-button>
+        <${P4}-button remove class="button button-danger delete"></${P4}-button>
+    </div>
+<div>
+<${P4}-shell-proxy>
+    <${P4}-modal-form core></${P4}-modal-form>
+    <${P4}-modal-form permissions></${P4}-modal-form>
+</${P4}-shell-proxy>`
+  })
+], PacemWidgetToolbarElement);
+var PacemWidgetElement = class extends Components.PacemElement {
+  constructor(metadata, role = "widget") {
+    super(role);
+    this.permissionMetadata = DEFAULT_PERMISSION_METADATA;
+    this.metadata = metadata;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    if (Utils4.isNullOrEmpty(this.id)) {
+      this.id = "wdg" + Utils4.uniqueCode();
+    }
+    Utils4.addClass(this, WIDGET_CSS_CLASS);
+  }
+  propertyChangedCallback(name, old, val, first) {
+    super.propertyChangedCallback(name, old, val, first);
+    switch (name) {
+      case "editable":
+        if (!val) {
+          this._disposeBalloon();
+        } else if (this.isReady) {
+          this._ensureBalloon();
+        }
+        break;
+      case "editing":
+        if (!Utils4.isNull(this._balloon)) {
+          this._balloon.disabled = !val;
+        }
+        (val ? Utils4.addClass : Utils4.removeClass).apply(this, [this, "widget-" + name]);
+        break;
+      case "metadata":
+        this._assignIcon(val);
+        break;
+    }
+  }
+  viewActivatedCallback() {
+    super.viewActivatedCallback();
+    this._assignIcon();
+    this._ensureBalloon();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+  }
+  _assignIcon(val = this.metadata) {
+    this.dataset["icon"] = val && val.display && val.display.icon || "widgets";
+  }
+  _ensureBalloon() {
+    if (Utils4.isNull(this._balloon)) {
+      const balloon = this._balloon = document.createElement(P4 + "-balloon");
+      balloon.target = this;
+      balloon.disabled = !this.editing;
+      balloon.options = {
+        behavior: UI.BalloonBehavior.Menu,
+        trigger: UI.BalloonTrigger.Hover
+      };
+      balloon.innerHTML = `<${P4}-widget-toolbar target="{{ #${this.id} }}"><${P4}-widget-toolbar>`;
+      CustomElementUtils3.findAncestorShell(this).appendChild(balloon);
+    }
+  }
+  _disposeBalloon() {
+    if (!Utils4.isNull(this._balloon)) {
+      this._balloon.remove();
+      this._balloon = null;
+    }
+  }
+};
+__decorate3([
+  Watch3({ emit: false, converter: PropertyConverters3.Boolean })
+], PacemWidgetElement.prototype, "editing", void 0);
+__decorate3([
+  Watch3({ emit: false, converter: PropertyConverters3.Boolean })
+], PacemWidgetElement.prototype, "editable", void 0);
+__decorate3([
+  Watch3({ emit: true, reflectBack: true, converter: PropertyConverters3.String })
+], PacemWidgetElement.prototype, "tag", void 0);
+__decorate3([
+  Watch3({ emit: false, reflectBack: true, converter: PropertyConverters3.Json })
+], PacemWidgetElement.prototype, "permissions", void 0);
+__decorate3([
+  Watch3({ emit: false, converter: PropertyConverters3.Json })
+], PacemWidgetElement.prototype, "metadata", void 0);
+__decorate3([
+  Watch3({ emit: false, converter: PropertyConverters3.Json })
+], PacemWidgetElement.prototype, "permissionMetadata", void 0);
+
+// packages/cms/dist/esm/widgets/helpers/types.js
+import { Watch as Watch6, PropertyConverters as PropertyConverters6, Utils as Utils6 } from "@pacem/pacem-core";
+
+// packages/cms/dist/esm/widgets/helpers/data.js
+import { CustomElement as CustomElement4, P as P5, PCSS as PCSS3, Watch as Watch4, PropertyConverters as PropertyConverters4 } from "@pacem/pacem-core";
+var __decorate4 = 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 DATA_METADATA = {
+  display: { icon: "storage", name: "Data", description: "Data object widget." },
+  props: [
+    {
+      prop: "model",
+      type: EXPRESSION_METADATA_TYPE,
+      display: {
+        name: "Model"
+      },
+      extra: {
+        selector: "." + PCSS3 + "-widget"
+      }
+    }
+  ]
+};
+var PacemWidgetDataElement = class PacemWidgetDataElement2 extends PacemWidgetElement {
+  constructor() {
+    super(buildWidgetMetadata(DATA_METADATA));
+  }
+};
+__decorate4([
+  Watch4({ reflectBack: true, converter: PropertyConverters4.Json })
+], PacemWidgetDataElement.prototype, "model", void 0);
+PacemWidgetDataElement = __decorate4([
+  CustomElement4({
+    tagName: P5 + "-widget-data"
+  })
+], PacemWidgetDataElement);
+
+// packages/cms/dist/esm/widgets/helpers/fetcher.js
+import { CustomElement as CustomElement5, P as P6, Defaults as Defaults4, Watch as Watch5, PropertyConverters as PropertyConverters5, ViewChild as ViewChild4, Utils as Utils5, CustomElementUtils as CustomElementUtils4, PacemEventTarget, Net } from "@pacem/pacem-core";
+var __decorate5 = 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 FETCH_PARAMETER_METADATA = {
+  props: [
+    { prop: "name", type: "string", isReadOnly: true, display: { name: "Name", cssClass: ["cols-md-4", "cols-lg-3", "cols-hd-2"] } },
+    { prop: "value", type: EXPRESSION_METADATA_TYPE, display: { name: "Value", cssClass: ["cols-md-8", "cols-lg-9", "cols-hd-10"] } }
+  ]
+};
+var FETCH_METADATA = {
+  display: {
+    icon: "wifi",
+    name: "Api Fetcher",
+    description: "Fetching widget that retrieves data from a REST endpoint."
+  },
+  props: [
+    {
+      prop: "manifest",
+      type: EXPRESSION_METADATA_TYPE,
+      isComplexType: true,
+      display: {
+        name: "Api Manifest"
+      },
+      extra: {
+        selector: P6 + "-widget-apimanifest"
+      },
+      validators: [{ type: "required", errorMessage: "Api Manifest is a required field." }]
+    },
+    {
+      prop: "endpoint",
+      type: "object",
+      isComplexType: true,
+      display: {
+        name: "Endpoint",
+        ui: "oneToMany"
+      },
+      validators: [{ type: "required", errorMessage: "Api Manifest is a required field." }],
+      extra: {
+        source: (manifest) => manifest.endpoints.map((e) => Utils5.extend(e, { "fullPath": `[${e.method.toUpperCase()}] ${e.path}` })).sort(),
+        textProperty: "fullPath",
+        valueProperty: "fullPath",
+        dependsOn: [{ prop: "manifest", hide: true }]
+      }
+    },
+    {
+      prop: "parameters",
+      type: "array",
+      display: {
+        name: "Parameters"
+      },
+      props: gridifyMetadata(FETCH_PARAMETER_METADATA),
+      extra: {
+        lockItems: true,
+        dependsOn: [{ prop: "endpoint", hide: true }]
+      }
+    },
+    ACCESS_TOKEN_METADATA
+  ]
+};
+var PARAMETER_TAGNAME = P6 + "-widget-fetch-parameter";
+var PacemWidgetFetchParameterElement = class PacemWidgetFetchParameterElement2 extends PacemEventTarget {
+  propertyChangedCallback(name, old, val, first) {
+    super.propertyChangedCallback(name, old, val.first);
+    if (name === "value" && !Utils5.isNull(this._fetcher)) {
+      this._fetcher.fetch();
+    }
+  }
+  viewActivatedCallback() {
+    super.viewActivatedCallback();
+    const fetcher = this._fetcher = CustomElementUtils4.findAncestorOfType(this, PacemWidgetFetchElement);
+    if (!Utils5.isNull(this._fetcher) && !Utils5.isNull(this.value)) {
+      this._fetcher.fetch();
+    }
+  }
+};
+__decorate5([
+  Watch5({ reflectBack: true, converter: PropertyConverters5.Boolean })
+], PacemWidgetFetchParameterElement.prototype, "required", void 0);
+__decorate5([
+  Watch5({ reflectBack: true, converter: PropertyConverters5.String })
+], PacemWidgetFetchParameterElement.prototype, "name", void 0);
+__decorate5([
+  Watch5({ reflectBack: true, converter: PropertyConverters5.String })
+], PacemWidgetFetchParameterElement.prototype, "value", void 0);
+PacemWidgetFetchParameterElement = __decorate5([
+  CustomElement5({ tagName: PARAMETER_TAGNAME })
+], PacemWidgetFetchParameterElement);
+var PacemWidgetFetchElement = class PacemWidgetFetchElement2 extends PacemBearerWidgetElement {
+  constructor() {
+    super(buildWidgetMetadata(FETCH_METADATA));
+    this._onerror = (e) => {
+      this.failure = !(this.success = false);
+    };
+    this._onsuccess = (e) => {
+      this.failure = !(this.success = true);
+    };
+    this._onresult = (e) => {
+      this.result = e.detail;
+    };
+  }
+  get _parameters() {
+    return Array.from(this._itemsElement.children).filter((e) => e.localName === PARAMETER_TAGNAME);
+  }
+  fetch() {
+    const fetcher = this._fetcher, parameters = this._parameters || [], endpoint = this.endpoint;
+    if (!Utils5.isNull(endpoint)) {
+      for (let param of endpoint.parameters) {
+        if (param.required && Utils5.isNull(parameters.find((p) => p.name === param.name))) {
+          return;
+        }
+      }
+    }
+    const params = {};
+    for (let parameter of parameters) {
+      if (!Utils5.isNullOrEmpty(parameter.value)) {
+        params[parameter.name] = parameter.value;
+      } else if (parameter.required) {
+        return;
+      }
+    }
+    fetcher.url = this.url;
+    fetcher.method = this.method;
+    fetcher.credentials = this.fetchCredentials;
+    fetcher.headers = this.fetchHeaders;
+    fetcher.parameters = params;
+    return fetcher.fetch();
+  }
+  viewActivatedCallback() {
+    super.viewActivatedCallback();
+    this.fetch();
+  }
+  propertyChangedCallback(name, old, val, first) {
+    super.propertyChangedCallback(name, old, val, first);
+    if (name === "endpoint" && !Utils5.isNullOrEmpty(val)) {
+      this._mergeEndpoint(val);
+    } else
+      switch (name) {
+        case "parameters":
+        case "fetchHeaders":
+        case "fetchCredentials":
+        case "url":
+        case "method":
+          this.fetch();
+          break;
+      }
+  }
+  _mergeEndpoint(endpoint = this.endpoint) {
+    this.url = this.manifest.baseUrl + endpoint.path;
+    this.method = endpoint.method;
+    this.fields = endpoint.response.fields;
+    const itemsElement = this._itemsElement, parameters = this._parameters;
+    for (let j = parameters.length - 1; j >= 0; j--) {
+      let item = parameters[j];
+      let matching = endpoint.parameters.find((p) => p.name === item.name);
+      if (Utils5.isNull(matching)) {
+        item.remove();
+      }
+    }
+    for (let param of endpoint.parameters) {
+      let existing = parameters.find((p) => p.name === param.name);
+      if (Utils5.isNull(existing)) {
+        let item = existing = document.createElement(PARAMETER_TAGNAME);
+        item.name = param.name;
+        itemsElement.appendChild(item);
+      }
+      existing.required = param.required;
+    }
+    this.parameters = parameters;
+  }
+};
+__decorate5([
+  Watch5({ reflectBack: true, emit: true, converter: PropertyConverters5.Json })
+], PacemWidgetFetchElement.prototype, "manifest", void 0);
+__decorate5([
+  Watch5({ reflectBack: true, emit: true, converter: PropertyConverters5.Json })
+], PacemWidgetFetchElement.prototype, "endpoint", void 0);
+__decorate5([
+  Watch5({ reflectBack: true, emit: false, converter: PropertyConverters5.String })
+], PacemWidgetFetchElement.prototype, "url", void 0);
+__decorate5([
+  Watch5({ reflectBack: true, emit: false, converter: PropertyConverters5.String })
+], PacemWidgetFetchElement.prototype, "method", void 0);
+__decorate5([
+  Watch5({ reflectBack: true, emit: false, converter: PropertyConverters5.Json })
+], PacemWidgetFetchElement.prototype, "fields", void 0);
+__decorate5([
+  Watch5(
+    /* just for editing sake */
+  )
+], PacemWidgetFetchElement.prototype, "parameters", void 0);
+__decorate5([
+  Watch5(
+    /* can only be databound or assigned at runtime */
+  )
+], PacemWidgetFetchElement.prototype, "result", void 0);
+__decorate5([
+  Watch5({ converter: PropertyConverters5.Boolean })
+], PacemWidgetFetchElement.prototype, "fetching", void 0);
+__decorate5([
+  Watch5({ converter: PropertyConverters5.Boolean })
+], PacemWidgetFetchElement.prototype, "success", void 0);
+__decorate5([
+  Watch5({ converter: PropertyConverters5.Boolean })
+], PacemWidgetFetchElement.prototype, "failure", void 0);
+__decorate5([
+  ViewChild4(P6 + "-fetch")
+], PacemWidgetFetchElement.prototype, "_fetcher", void 0);
+__decorate5([
+  ViewChild4("div[hidden]")
+], PacemWidgetFetchElement.prototype, "_itemsElement", void 0);
+PacemWidgetFetchElement = __decorate5([
+  CustomElement5({
+    tagName: P6 + "-widget-fetch",
+    shadow: Defaults4.USE_SHADOW_ROOT,
+    template: `<${P6}-fetch autofetch="false" fetching="{{ :host.fetching, twoway }}" debounce="100"
+on-${Net.FetchResultEventName}=":host._onresult($event)" on-${Net.FetchErrorEventName}=":host._onerror($event)" on-${Net.FetchSuccessEventName}=":host._onsuccess($event)"></${P6}-fetch><div hidden><${P6}-content></${P6}-content></div>`
+  })
+], PacemWidgetFetchElement);
+
+// packages/cms/dist/esm/widgets/helpers/types.js
+var __decorate6 = 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 FETCH_CREDENTIALS_METADATA = {
+  prop: "fetchCredentials",
+  type: "string",
+  dataType: "enumeration",
+  display: { name: "Fetch Credentials" },
+  extra: {
+    enum: ["same-origin", "omit", "include"]
+  }
+};
+var ACCESS_TOKEN_METADATA = {
+  prop: "accessToken",
+  type: EXPRESSION_METADATA_TYPE,
+  display: { name: "Access Token" },
+  extra: Utils6.extend({}, EXPRESSION_WIDGET_METADATA_EXTRA, { filter: (e) => e instanceof PacemWidgetDataElement || e instanceof PacemWidgetFetchElement })
+};
+var PacemBearerWidgetElement = class extends PacemWidgetElement {
+  constructor() {
+    super(...arguments);
+    this.fetchCredentials = "same-origin";
+  }
+  propertyChangedCallback(name, old, val, first) {
+    super.propertyChangedCallback(name, old, val, first);
+    if (name === "accessToken") {
+      if (!Utils6.isNullOrEmpty(val)) {
+        this.fetchHeaders = { "Authorization": "Bearer " + val };
+      } else {
+        this.fetchHeaders = {};
+      }
+    }
+  }
+};
+__decorate6([
+  Watch6({ emit: false, reflectBack: true, converter: PropertyConverters6.String })
+], PacemBearerWidgetElement.prototype, "fetchCredentials", void 0);
+__decorate6([
+  Watch6({ emit: false, converter: PropertyConverters6.Json })
+], PacemBearerWidgetElement.prototype, "fetchHeaders", void 0);
+__decorate6([
+  Watch6({ emit: false, reflectBack: true, converter: PropertyConverters6.String })
+], PacemBearerWidgetElement.prototype, "accessToken", void 0);
+__decorate6([
+  Watch6({ converter: PropertyConverters6.Boolean })
+], PacemBearerWidgetElement.prototype, "fetching", void 0);
+
+// packages/cms/dist/esm/widgets/helpers/translator.js
+import { CustomElement as CustomElement6, P as P7 } from "@pacem/pacem-core";
+var __decorate7 = 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 PacemWidgetTranslatorElement = class PacemWidgetTranslatorElement2 extends PacemWidgetElement {
+};
+PacemWidgetTranslatorElement = __decorate7([
+  CustomElement6({
+    tagName: P7 + "-widget-translator"
+  })
+], PacemWidgetTranslatorElement);
+
+// packages/cms/dist/esm/widgets/helpers/clock.js
+import { CustomElement as CustomElement7, P as P8, PCSS as PCSS4, Watch as Watch7, PropertyConverters as PropertyConverters7 } from "@pacem/pacem-core";
+var __decorate8 = 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 DATA_METADATA2 = {
+  display: { icon: "timer", name: "Clock", description: "Timer widget." },
+  props: [
+    {
+      prop: "interval",
+      type: EXPRESSION_METADATA_TYPE,
+      display: {
+        name: "Interval (msec)"
+      },
+      extra: {
+        selector: "." + PCSS4 + "-widget",
+        step: 1e3
+      },
+      validators: [{
+        type: "range",
+        errorMessage: "Negative numbers not allowed",
+        params: { min: 0 }
+      }]
+    }
+  ]
+};
+var PacemWidgetClockElement = class PacemWidgetClockElement2 extends PacemWidgetElement {
+  constructor() {
+    super(buildWidgetMetadata(DATA_METADATA2));
+    this.interval = 0;
+  }
+};
+__decorate8([
+  Watch7({ reflectBack: true, converter: PropertyConverters7.Number })
+], PacemWidgetClockElement.prototype, "interval", void 0);
+__decorate8([
+  Watch7({ converter: PropertyConverters7.Number })
+], PacemWidgetClockElement.prototype, "time", void 0);
+PacemWidgetClockElement = __decorate8([
+  CustomElement7({
+    tagName: P8 + "-widget-clock",
+    template: `<${P8}-timer interval="{{ :host.interval }}" on-tick="{{ :host.time = Date.now() }}"></${P8}-timer>`
+  })
+], PacemWidgetClockElement);
+
+// packages/cms/dist/esm/widgets/helpers/apimanifest.js
+import { CustomElement as CustomElement8, P as P9, Watch as Watch8, PropertyConverters as PropertyConverters8, Utils as Utils7, Storage } from "@pacem/pacem-core";
+
+// packages/cms/dist/esm/openapi/swagger-cms.js
+var swagger_cms_exports = {};
+__export(swagger_cms_exports, {
+  SwaggerCmsParser: () => SwaggerCmsParser
+});
+import { Scaffolding } from "@pacem/pacem-scaffolding";
+var BAG = "pacem:metadatabag";
+var SwaggerCmsParser = class {
+  constructor(_openApi = new Scaffolding.OpenApi.OpenApiParser()) {
+    this._openApi = _openApi;
+    this._cachedMetadataUrls = [];
+  }
+  async load(url, headers) {
+    let api = await this._openApi.load(url, headers);
+    if (api != null) {
+      api[BAG] = {};
+      for (let endpoint of api.endpoints) {
+        await this._enrichSchemas(api, endpoint, headers);
+      }
+    }
+    return api;
+  }
+  async _enrichSchemas(api, endpoint, headers) {
+    const response = endpoint.response;
+    if (response && response.meta) {
+      response.fields = await this._fetchMetadata(api, { name: response.fullType, schema: response.meta }, headers);
+    }
+    const parameters = endpoint.parameters;
+    for (let parameter of parameters || []) {
+      if (parameter.meta && parameter.fullType) {
+        let fields = await this._fetchMetadata(api, { name: parameter.fullType, schema: parameter.meta }, headers);
+        parameter.fields = fields;
+      }
+    }
+  }
+  clearCache() {
+    const cache = this.cache, keys = this._cachedMetadataUrls;
+    if (cache) {
+      for (let key of keys) {
+        cache.removeProperty(key);
+      }
+      keys.splice(0);
+    }
+  }
+  /**
+   *
+   * @param def1
+   * @param headers HTTP headers for API fetching
+   */
+  async _fetchMetadata(api, def0, headers) {
+    let _fetch = async (def1) => {
+      let cols = [];
+      if (def1 && def1.name) {
+        if (api[BAG][def1.name]) {
+          return api[BAG][def1.name];
+        }
+        api[BAG][def1.name] = cols;
+        let meta = { props: [] }, metadataUrl;
+        if (/^https?:\/\//.test(def1.name)) {
+          metadataUrl = def1.name;
+        } else {
+          console.warn(`Swagger entity definition keys must appear in form of absolute url. Their response to a GET request needs to be the entity metadata itself.
+No other options are currently supported.`);
+          return;
+        }
+        if (metadataUrl) {
+          let retrieveFn = async () => {
+            let response = await fetch(metadataUrl, { credentials: "omit", mode: "cors", headers });
+            if (response.ok) {
+              return await response.json();
+            }
+          };
+          if (this.cache) {
+            meta = this.cache.getPropertyValue(metadataUrl);
+            if (!meta) {
+              meta = await retrieveFn();
+              this._cachedMetadataUrls.push(metadataUrl);
+              this.cache.setPropertyValue(
+                metadataUrl,
+                meta,
+                /* persist in session not on location */
+                false
+              );
+            }
+          } else {
+            meta = await retrieveFn();
+          }
+        }
+        let schema = def1.schema;
+        for (let col in schema.properties) {
+          let column = schema.properties[col], field = meta && meta.props.find((p) => p.prop === col);
+          let datafield = Object.assign({
+            prop: col,
+            type: column.type || "text",
+            props: void 0
+          }, field || /* if there's no match, then read-only */
+          { isReadOnly: true });
+          if (field) {
+            let $ref = column.items && column.items.$ref || column.$ref;
+            if ($ref) {
+              let ref = Scaffolding.OpenApi.getOpenApiDefinition(api, $ref), key = ref.name;
+              if (api[BAG][key]) {
+                datafield.props = api[BAG][key];
+              } else {
+                datafield.props = await _fetch(ref);
+              }
+            }
+          }
+          cols.push(datafield);
+        }
+      }
+      return cols;
+    };
+    return await _fetch(def0);
+  }
+};
+
+// packages/cms/dist/esm/widgets/helpers/apimanifest.js
+var __decorate9 = 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 APIMANIFEST_METADATA = {
+  display: { icon: "cloud_circle", name: "Api Manifest", description: "OpenApi parser for WebApi scaffolding." },
+  props: [
+    {
+      prop: "url",
+      type: "text",
+      display: {
+        name: "Url",
+        description: "Insert the url of the OpenApi json configuration.",
+        cssClass: ["cols-lg-8"],
+        watermark: "https://domain.com/swagger/v1/swagger.json"
+      },
+      extra: { tooltip: true },
+      validators: [{
+        type: "required",
+        errorMessage: "Url field is required."
+      }]
+    },
+    {
+      prop: "usecache",
+      type: "boolean",
+      display: {
+        name: "Cache results",
+        description: "Whether to cache the manifest per-url.",
+        cssClass: ["cols-lg-4"],
+        ui: "switcher"
+      },
+      extra: { tooltip: true }
+    },
+    ACCESS_TOKEN_METADATA
+  ]
+};
+var PacemWidgetApiManifestElement = class PacemWidgetApiManifestElement2 extends PacemBearerWidgetElement {
+  constructor(_openapi = new SwaggerCmsParser(), _cache = new Storage()) {
+    super(buildWidgetMetadata(APIMANIFEST_METADATA));
+    this._openapi = _openapi;
+    this._cache = _cache;
+  }
+  propertyChangedCallback(name, old, val, first) {
+    super.propertyChangedCallback(name, old, val, first);
+    switch (name) {
+      case "url":
+      case "editing":
+      case "editable":
+        this._scaffold();
+        break;
+      case "usecache":
+        this._openapi.cache = val ? this._cache : null;
+        break;
+    }
+  }
+  viewActivatedCallback() {
+    super.viewActivatedCallback();
+    if (this.usecache) {
+      this._openapi.cache = this._cache;
+    }
+    this._scaffold();
+  }
+  _scaffold() {
+    if (this.editing && this.editable && !Utils7.isNullOrEmpty(this.url)) {
+      this.fetching = true;
+      this._openapi.load(this.url).then((s) => {
+        this.manifest = s;
+        this.fetching = false;
+      }, (_) => {
+        this.fetching = false;
+      });
+    }
+  }
+};
+__decorate9([
+  Watch8({ emit: false, reflectBack: true, converter: PropertyConverters8.String })
+], PacemWidgetApiManifestElement.prototype, "url", void 0);
+__decorate9([
+  Watch8({ emit: false, reflectBack: true, converter: PropertyConverters8.Boolean })
+], PacemWidgetApiManifestElement.prototype, "usecache", void 0);
+__decorate9([
+  Watch8({ converter: PropertyConverters8.Json })
+], PacemWidgetApiManifestElement.prototype, "manifest", void 0);
+PacemWidgetApiManifestElement = __decorate9([
+  CustomElement8({ tagName: P9 + "-widget-apimanifest" })
+], PacemWidgetApiManifestElement);
+
+// packages/cms/dist/esm/widgets/ui/types.js
+import { Watch as Watch9, PropertyConverters as PropertyConverters9, Utils as Utils8, CustomElementUtils as CustomElementUtils5, Logging, PCSS as PCSS5 } from "@pacem/pacem-core";
+var __decorate10 = 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 PacemUiWidgetElement = class extends PacemWidgetElement {
+  constructor(metadata, colspan = 1, role) {
+    super(metadata, role);
+    this.colspan = colspan;
+    this.rowspan = 1;
+  }
+  // just a flag class
+  connectedCallback() {
+    super.connectedCallback();
+    Utils8.addClass(this, "ui-widget " + PCSS5 + "-cell cols-xs-start-1 cols-xs-12 rows-xs-start-auto");
+  }
+  propertyChangedCallback(name, old, val, first) {
+    super.propertyChangedCallback(name, old, val, first);
+    switch (name) {
+      case "row":
+        Utils8.removeClass(this, `rows-start-${old + 1}`);
+        Utils8.addClass(this, `rows-start-${val + 1}`);
+        break;
+      case "rowspan":
+        Utils8.removeClass(this, `rows-${old}`);
+        Utils8.addClass(this, `rows-${val}`);
+        break;
+      case "column":
+        Utils8.removeClass(this, `cols-start-${old + 1}`);
+        Utils8.addClass(this, `cols-start-${val + 1}`);
+        break;
+      case "colspan":
+        Utils8.removeClass(this, `cols-${old}`);
+        Utils8.addClass(this, `cols-${val}`);
+        break;
+      case "borders":
+        (this.borders ? Utils8.addClass : Utils8.removeClass).apply(this, [this, PCSS5 + "-border"]);
+        break;
+      case "corners":
+        (this.borders ? Utils8.addClass : Utils8.removeClass).apply(this, [this, PCSS5 + "-corners"]);
+        break;
+    }
+  }
+  get container() {
+    return this._container;
+  }
+  /** @overridable */
+  findContainer() {
+    return CustomElementUtils5.findAncestor(this, (n) => n instanceof PacemCompositeWidgetElement);
+  }
+  viewActivatedCallback() {
+    super.viewActivatedCallback();
+    let iter = this._container = this.findContainer();
+    if (!Utils8.isNull(iter)) {
+      iter.register(this);
+    }
+  }
+  disconnectedCallback() {
+    if (!Utils8.isNull(this._container)) {
+      this._container.unregister(this);
+    }
+    super.disconnectedCallback();
+  }
+};
+__decorate10([
+  Watch9({ emit: true, reflectBack: true, converter: PropertyConverters9.Number })
+], PacemUiWidgetElement.prototype, "column", void 0);
+__decorate10([
+  Watch9({ emit: true, reflectBack: true, converter: PropertyConverters9.Number })
+], PacemUiWidgetElement.prototype, "row", void 0);
+__decorate10([
+  Watch9({ emit: true, reflectBack: true, converter: PropertyConverters9.Number })
+], PacemUiWidgetElement.prototype, "colspan", void 0);
+__decorate10([
+  Watch9({ emit: true, reflectBack: true, converter: PropertyConverters9.Number })
+], PacemUiWidgetElement.prototype, "rowspan", void 0);
+__decorate10([
+  Watch9({ emit: true, reflectBack: true, converter: PropertyConverters9.Boolean })
+], PacemUiWidgetElement.prototype, "borders", void 0);
+__decorate10([
+  Watch9({ emit: true, reflectBack: true, converter: PropertyConverters9.Boolean })
+], PacemUiWidgetElement.prototype, "corners", void 0);
+var WidgetRegisterEventName = "widgetregister";
+var WidgetUnregisterEventName = "widgetunregister";
+var LayoutChangeEventName = "layoutchange";
+var WidgetRegisterEvent = class extends CustomEvent {
+  constructor(item, eventInit) {
+    super(WidgetRegisterEventName, Utils8.extend(eventInit || {}, { detail: item }));
+  }
+};
+var WidgetUnregisterEvent = class extends CustomEvent {
+  constructor(item, eventInit) {
+    super(WidgetUnregisterEventName, Utils8.extend(eventInit || {}, { detail: item }));
+  }
+};
+var PacemCompositeWidgetElement = class extends PacemUiWidgetElement {
+  get itemsElement() {
+    return this;
+  }
+  validate(item) {
+    return item instanceof PacemUiWidgetElement;
+  }
+  viewActivatedCallback() {
+    super.viewActivatedCallback();
+    Utils8.addClass(this.itemsElement, PCSS5 + "-items-element");
+  }
+  /**
+   * Appends a child Element to this CompositeWidget's itemsElement.
+   * @param item New child element
+   */
+  appendItem(item) {
+    this.itemsElement.appendChild(item);
+  }
+  /**
+   * Registers a new item among the items.
+   * @param item {PacemUiWidgetElement} Item to be enrolled
+   */
+  register(item) {
+    if (!this.validate(item)) {
+      this.log(Logging.LogLevel.Debug, `${item && item.localName} element couldn't be registered in a ${this.localName} element.`);
+      return false;
+    }
+    let retval = false;
+    const items = this.items = this.items || [];
+    if (Utils8.isNullOrEmpty(items)) {
+      this.items = [item];
+      retval = true;
+    } else if (items.indexOf(item) === -1) {
+      items.push(item);
+      retval = true;
+    }
+    if (retval) {
+      this.dispatchEvent(new WidgetRegisterEvent(item));
+    }
+    return retval;
+  }
+  /**
+   * Removes an existing element from the items.
+   * @param item {PacemUiWidgetElement} Item to be removed
+   */
+  unregister(item) {
+    const items = this.items, ndx = !Utils8.isNullOrEmpty(items) && items.indexOf(item);
+    if (ndx >= 0) {
+      let item2 = items.splice(ndx, 1);
+      this.dispatchEvent(new WidgetUnregisterEvent(item2[0]));
+      return true;
+    }
+    return false;
+  }
+};
+__decorate10([
+  Watch9(
+    /* can only be databound or assigned at runtime */
+  )
+], PacemCompositeWidgetElement.prototype, "items", void 0);
+
+// packages/cms/dist/esm/widgets/ui/text.js
+import { CustomElement as CustomElement9, P as P10, Defaults as Defaults5, Watch as Watch10, PropertyConverters as PropertyConverters10 } from "@pacem/pacem-core";
+var __decorate11 = 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 TEXT_METADATA = buildWidgetMetadata({
+  display: { icon: "font_download", name: "Text", description: "Plain text widget." },
+  props: [{
+    prop: "text",
+    type: EXPRESSION_METADATA_TYPE,
+    display: { name: "Text" },
+    extra: EXPRESSION_WIDGET_METADATA_EXTRA
+  }]
+});
+var PacemWidgetTextElement = class PacemWidgetTextElement2 extends PacemUiWidgetElement {
+  constructor() {
+    super(TEXT_METADATA);
+  }
+};
+__decorate11([
+  Watch10({ reflectBack: true, converter: PropertyConverters10.String })
+], PacemWidgetTextElement.prototype, "text", void 0);
+PacemWidgetTextElement = __decorate11([
+  CustomElement9({
+    tagName: P10 + "-widget-text",
+    shadow: Defaults5.USE_SHADOW_ROOT,
+    template: `<${P10}-text text="{{ :host.text }}"></${P10}-text>`
+  })
+], PacemWidgetTextElement);
+
+// packages/cms/dist/esm/widgets/ui/composite/picker.js
+import { CustomElement as CustomElement10, P as P11, PCSS as PCSS6, Defaults as Defaults6, ViewChild as ViewChild5 } from "@pacem/pacem-core";
+var __decorate12 = 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 PacemWidgetPickerElement = class PacemWidgetPickerElement2 extends PacemCompositeWidgetElement {
+  register(item) {
+    const retval = super.register(item);
+    if (retval) {
+      item.hide = true;
+    }
+    return retval;
+  }
+};
+__decorate12([
+  ViewChild5(P11 + "-drag-drop")
+], PacemWidgetPickerElement.prototype, "_dragDrop", void 0);
+PacemWidgetPickerElement = __decorate12([
+  CustomElement10({
+    tagName: P11 + "-widget-picker",
+    shadow: Defaults6.USE_SHADOW_ROOT,
+    template: `<${P11}-repeater datasource="{{ :host.items }}">
+    <template>
+        <${P11}-panel behaviors="{{ [::_dragDrop] }}" class="${PCSS6}-widget-itempicker display-flex flex-fill flex-middle flex-nowrap">
+            <i class="${PCSS6}-icon flex-auto" dragger>drag_indicator</i>
+            <${P11}-icon icon="{{ ^item.metadata.display.icon }}" class="flex-auto ${PCSS6}-margin margin-x-1"></${P11}-icon>
+            <${P11}-text text="{{ ^item.metadata.display.name }}"></${P11}-text>
+        </${P11}-panel>
+    </template>
+</${P11}-repeater>
+<${P11}-drag-drop handle-selector="i.${PCSS6}-icon[dragger]"></${P11}-drag-drop>
+<${P11}-content></${P11}-content>`
+  })
+], PacemWidgetPickerElement);
+
+// packages/cms/dist/esm/widgets/ui/composite/grid.js
+import { CustomElement as CustomElement11, P as P12, PCSS as PCSS7, Watch as Watch11, PropertyConverters as PropertyConverters11, Debounce as Debounce3, Utils as Utils9, UI as UI2, PropertyChangeEventName as PropertyChangeEventName2 } from "@pacem/pacem-core";
+var __decorate13 = 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;
+};
+function createSvgGridBox() {
+  const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  svg.style.pointerEvents = "none";
+  svg.style.zIndex = "1000";
+  svg.setAttribute("height", "100%");
+  svg.setAttribute("width", "100%");
+  svg.setAttribute("preserveAspectRatio", "none");
+  svg.setAttribute("class", "grid-cell-wrapper");
+  svg.innerHTML = `<rect class="grid-cell" width="100%" height="100%"></rect>`;
+  return svg;
+}
+var GRID_COLUMNS = 12;
+var FALLBACK_COLUMNS = GRID_COLUMNS;
+var FALLBACK_ROWS = 1;
+var GRID_METADATA = {
+  display: {
+    icon: "grid_on",
+    name: "Grid",
+    description: "Composition Widget that lays out child-widgets in a grid container."
+  },
+  props: [
+    {
+      prop: "rows",
+      type: "int",
+      display: {
+        name: "Rows",
+        cssClass: ["cols-lg-4"]
+      },
+      validators: [
+        { type: "required", errorMessage: "" },
+        {
+          type: "range",
+          errorMessage: "",
+          params: {
+            min: 1,
+            max: 24
+          }
+        }
+      ]
+    },
+    {
+      prop: "rowGap",
+      type: "int",
+      display: {
+        //ui: 'slider',
+        name: "Row gap",
+        cssClass: ["cols-lg-4"]
+      },
+      validators: [
+        // { type: 'required', errorMessage: '' },
+        {
+          type: "range",
+          errorMessage: "",
+          params: {
+            min: 0,
+            max: 3,
+            step: 0.25
+          }
+        }
+      ]
+    },
+    {
+      prop: "columnGap",
+      type: "int",
+      display: {
+        //ui: 'slider',
+        name: "Column gap",
+        cssClass: ["cols-lg-4"]
+      },
+      validators: [
+        // { type: 'required', errorMessage: '' },
+        {
+          type: "range",
+          errorMessage: "",
+          params: {
+            min: 0,
+            max: 3,
+            step: 0.25
+          }
+        }
+      ]
+    }
+  ]
+};
+var PacemGridWidgetElement = class PacemGridWidgetElement2 extends PacemCompositeWidgetElement {
+  constructor() {
+    super(buildWidgetMetadata(GRID_METADATA), FALLBACK_COLUMNS, "grid");
+    this._widgetPropertyChange = (evt) => {
+      if (evt.detail.propertyName === "row" || evt.detail.propertyName === "rowspan") {
+        const widget = evt.target;
+        this.rows = Math.max(this.rows, widget.row + widget.rowspan);
+      }
+    };
+    this._dragDropHandler = (evt) => {
+      const args = evt.detail, el = args.element;
+      switch (evt.type) {
+        case UI2.DragDropEventType.Start:
+          this._gridBoxes.forEach((svg) => {
+            svg.style.pointerEvents = "auto";
+          });
+          this._initState = {
+            colspan: el.colspan,
+            rowspan: el.rowspan,
+            col: el.column,
+            row: el.row
+          };
+          break;
+        case UI2.DragDropEventType.End:
+          this._gridBoxes.forEach((svg) => {
+            svg.style.pointerEvents = "none";
+          });
+          break;
+        case UI2.DragDropEventType.Over:
+          var dropTarget = args.target;
+          var col = +dropTarget.style.gridColumnStart - 1;
+          var row = +dropTarget.style.gridRowStart - 1;
+          const farRight = col + this._initState.colspan, farBottom = row + this._initState.rowspan;
+          if (!this._intersects(el, col, row, el.colspan, el.rowspan)) {
+            let fireLayoutChange = false;
+            if (farRight <= (this.columns || FALLBACK_COLUMNS)) {
+              fireLayoutChange = el.column !== col;
+              el.column = col;
+            }
+            if (farBottom <= (this.rows || FALLBACK_ROWS)) {
+              fireLayoutChange = fireLayoutChange || el.row !== row;
+              el.row = row;
+            }
+            if (fireLayoutChange) {
+            }
+          }
+          break;
+      }
+      ;
+    };
+    this._resizeHandler = (evt) => {
+      switch (evt.type) {
+        case UI2.RescaleEventType.Start:
+          Utils9.addClass(evt.detail.element, PCSS7 + "-rescaling");
+          this._gridBoxes.forEach((svg) => {
+            svg.style.pointerEvents = "auto";
+          });
+          break;
+        case UI2.RescaleEventType.End:
+          this._gridBoxes.forEach((svg) => {
+            svg.style.pointerEvents = "none";
+          });
+          Utils9.removeClass(evt.detail.element, PCSS7 + "-rescaling");
+          break;
+        case UI2.RescaleEventType.Rescale:
+          evt.preventDefault();
+          const pos = { x: evt.clientX, y: evt.clientY }, handle = evt.detail.handle;
+          const dropTarget = document.elementsFromPoint(pos.x, pos.y).find((e) => this._dragDrop.dropTargets.indexOf(e) >= 0);
+          if (dropTarget) {
+            var col = +dropTarget.style.gridColumnStart;
+            var row = +dropTarget.style.gridRowStart;
+            const widget = evt.detail.element, startcol = widget.column + 1, startrow = widget.row + 1;
+            const colspan = 1 + col - startcol, rowspan = 1 + row - startrow;
+            if (!this._intersects(widget, widget.column, widget.row, colspan, rowspan)) {
+              let fireLayoutChange = false;
+              if (col >= startcol && handle.endsWith("right")) {
+                fireLayoutChange = widget.colspan !== colspan;
+                widget.colspan = colspan;
+              }
+              if (row >= startrow && handle.startsWith("bottom")) {
+                fireLayoutChange = fireLayoutChange || widget.rowspan !== rowspan;
+                widget.rowspan = rowspan;
+              }
+              if (fireLayoutChange) {
+              }
+            }
+          }
+          break;
+      }
+    };
+    this._gridBoxes = [];
+  }
+  register(item) {
+    let retval = super.register(item);
+    if (retval) {
+      const row = item.row || 0, column = item.column || 0, colspan = item.colspan || 2, rowspan = item.rowspan || 1;
+      let foundspot = !this._intersects(item, column, row, colspan, rowspan);
+      if (foundspot) {
+        item.row = row;
+        item.column = column;
+        item.colspan = colspan;
+        item.rowspan = rowspan;
+      } else {
+        if (!foundspot) {
+          let check = (elasticOnColspan = false) => {
+            let maxColIndex = this.columns - 1;
+            if (!elasticOnColspan) {
+              maxColIndex = maxColIndex - colspan + 1;
+            }
+            for (let j = 0; j < this.rows; j++) {
+              for (let i = 0; i <= maxColIndex; i++) {
+                if (!this._intersects(item, i, j, colspan, rowspan)) {
+                  item.column = i;
+                  item.row = j;
+                  item.colspan = Math.min(maxColIndex + 1 - i, colspan);
+                  item.rowspan = rowspan;
+                  foundspot = true;
+                  break;
+                }
+              }
+              if (foundspot)
+                break;
+            }
+          };
+          check();
+          if (!foundspot && colspan > 1) {
+            check(true);
+          }
+        }
+        if (!foundspot) {
+          this.rows++;
+          item.row = this.rows - 1;
+          item.column = 0;
+        }
+      }
+      item.behaviors = [this._dragDrop, this._rescaler];
+      item.addEventListener(PropertyChangeEventName2, this._widgetPropertyChange, false);
+    }
+    return retval;
+  }
+  unregister(item) {
+    let retval = super.unregister(item);
+    if (retval) {
+      item.removeEventListener(PropertyChangeEventName2, this._widgetPropertyChange, false);
+      const ndx = item.behaviors.indexOf(this._dragDrop);
+      if (ndx >= 0)
+        item.behaviors.splice(ndx, 1);
+      const ndx1 = item.behaviors.indexOf(this._rescaler);
+      if (ndx1 >= 0)
+        item.behaviors.splice(ndx1, 1);
+    }
+    return retval;
+  }
+  _intersects(who, col, row, colspan, rowspan) {
+    for (let item of this.items) {
+      let widget = item;
+      if (widget === who) {
+        continue;
+      }
+      if (widget.column < col + colspan && widget.column + widget.colspan > col && (widget.row < row + rowspan && widget.row + widget.rowspan > row)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    Utils9.addClass(this, PCSS7 + "-grid");
+    let dragDrop = this._dragDrop = document.createElement(P12 + "-drag-drop");
+    let floater = document.createElement("div");
+    document.body.appendChild(floater);
+    dragDrop.floater = floater;
+    dragDrop.mode = UI2.DragDataMode.Alias;
+    dragDrop.dropBehavior = UI2.DropBehavior.None;
+    dragDrop.addEventListener(UI2.DragDropEventType.Start, this._dragDropHandler, false);
+    dragDrop.addEventListener(UI2.DragDropEventType.Over, this._dragDropHandler, false);
+    dragDrop.addEventListener(UI2.DragDropEventType.End, this._dragDropHandler, false);
+    document.body.appendChild(dragDrop);
+    let rescale = this._rescaler = document.createElement(P12 + "-rescale");
+    rescale.handles = [UI2.RescaleHandle.Right, UI2.RescaleHandle.Bottom];
+    rescale.addEventListener(UI2.RescaleEventType.Start, this._resizeHandler, false);
+    rescale.addEventListener(UI2.RescaleEventType.Rescale, this._resizeHandler, false);
+    rescale.addEventListener(UI2.RescaleEventType.End, this._resizeHandler, false);
+    document.body.appendChild(rescale);
+    if (Utils9.isNullOrEmpty(this.columns)) {
+      this.columns = GRID_COLUMNS;
+    }
+    if (Utils9.isNullOrEmpty(this.rows)) {
+      this.rows = 1;
+    }
+  }
+  viewActivatedCallback() {
+    super.viewActivatedCallback();
+    this.adapt();
+  }
+  propertyChangedCallback(name, old, val, first) {
+    super.propertyChangedCallback(name, old, val, first);
+    this.adapt();
+  }
+  disconnectedCallback() {
+    var dragDrop = this._dragDrop, rescale = this._rescaler;
+    if (!Utils9.isNull(dragDrop)) {
+      dragDrop.floater.remove();
+      dragDrop.removeEventListener(UI2.DragDropEventType.Start, this._dragDropHandler, false);
+      dragDrop.removeEventListener(UI2.DragDropEventType.Over, this._dragDropHandler, false);
+      dragDrop.removeEventListener(UI2.DragDropEventType.End, this._dragDropHandler, false);
+      dragDrop.remove();
+      this._dragDrop = null;
+    }
+    if (!Utils9.isNull(rescale)) {
+      rescale.removeEventListener(UI2.RescaleEventType.Start, this._resizeHandler, false);
+      rescale.removeEventListener(UI2.RescaleEventType.Rescale, this._resizeHandler, false);
+      rescale.removeEventListener(UI2.RescaleEventType.End, this._resizeHandler, false);
+      rescale.remove();
+      this._rescaler = null;
+    }
+    super.disconnectedCallback();
+  }
+  _normalize(measure, defaultValue = 1) {
+    if (typeof measure === "string") {
+      return measure;
+    } else if (measure == null) {
+      measure = defaultValue;
+    }
+    return this.unitPixels(measure) + "px";
+  }
+  unitPixels(qty) {
+    return qty * (this.unit || 8);
+  }
+  adapt() {
+    this.style.marginTop = this.unitPixels(this.marginTop || 0) + "px";
+    this.style.marginBottom = this.unitPixels(this.marginBottom || 0) + "px";
+    this.style.gridTemplateColumns = `repeat(${this.columns || FALLBACK_COLUMNS}, 1fr)`;
+    let minrowheight = this._normalize(this.minRowheight, 3), rowheight = this._normalize(this.rowheight || "auto");
+    this.style.gridTemplateRows = `repeat(${this.rows || FALLBACK_ROWS}, minmax(${minrowheight}, ${rowheight}))`;
+    this.style.gridRowGap = this._normalize(this.rowGap, 1);
+    this.style.gridColumnGap = this._normalize(this.columnGap, 1);
+    this._setGridLines();
+  }
+  _setGridLines() {
+    var splice = 0;
+    const editing = this.editing;
+    if (editing) {
+      const cols = this.columns || FALLBACK_COLUMNS, rows = this.rows || FALLBACK_ROWS, total = cols * rows;
+      splice = total;
+      for (let k = 0; k < total; k++) {
+        while (this._gridBoxes.length <= k) {
+          let s = createSvgGridBox();
+          this.appendChild(s);
+          this._gridBoxes.push(s);
+        }
+        let svg = this._gridBoxes[k];
+        const i = k % cols, j = Math.floor(k / cols);
+        svg.style.gridColumn = (i + 1).toString();
+        svg.style.gridRow = (j + 1).toString();
+      }
+    }
+    for (let svg of this._gridBoxes.splice(splice)) {
+      svg.remove();
+    }
+    if (!Utils9.isNull(this._dragDrop) && !Utils9.isNull(this._rescaler)) {
+      this._dragDrop.disabled = this._rescaler.disabled = !editing;
+      this._dragDrop.dropTargets = this._gridBoxes;
+    }
+  }
+};
+__decorate13([
+  Watch11({ emit: false, reflectBack: true, converter: PropertyConverters11.Number })
+], PacemGridWidgetElement.prototype, "unit", void 0);
+__decorate13([
+  Watch11({ emit: false, reflectBack: true, converter: PropertyConverters11.Number })
+], PacemGridWidgetElement.prototype, "marginTop", void 0);
+__decorate13([
+  Watch11({ emit: false, reflectBack: true, converter: PropertyConverters11.Number })
+], PacemGridWidgetElement.prototype, "marginBottom", void 0);
+__decorate13([
+  Watch11({ emit: false, reflectBack: true, converter: PropertyConverters11.Number })
+], PacemGridWidgetElement.prototype, "columns", void 0);
+__decorate13([
+  Watch11({ emit: false, reflectBack: true, converter: PropertyConverters11.Number })
+], PacemGridWidgetElement.prototype, "rows", void 0);
+__decorate13([
+  Watch11({ emit: false, reflectBack: true, converter: PropertyConverters11.String })
+], PacemGridWidgetElement.prototype, "minRowheight", void 0);
+__decorate13([
+  Watch11({ emit: false, reflectBack: true, converter: PropertyConverters11.String })
+], PacemGridWidgetElement.prototype, "rowheight", void 0);
+__decorate13([
+  Watch11({ emit: false, reflectBack: true, converter: PropertyConverters11.Number })
+], PacemGridWidgetElement.prototype, "rowGap", void 0);
+__decorate13([
+  Watch11({ emit: false, reflectBack: true, converter: PropertyConverters11.Number })
+], PacemGridWidgetElement.prototype, "columnGap", void 0);
+__decorate13([
+  Debounce3(100)
+], PacemGridWidgetElement.prototype, "adapt", null);
+PacemGridWidgetElement = __decorate13([
+  CustomElement11({ tagName: P12 + "-widget-grid" })
+], PacemGridWidgetElement);
+
+// packages/cms/dist/esm/widgets/ui/dataviz/datagrid.js
+import { CustomElement as CustomElement13, P as P14, PCSS as PCSS9, Watch as Watch13, PropertyConverters as PropertyConverters13, ViewChild as ViewChild7, Utils as Utils11, Components as Components3 } from "@pacem/pacem-core";
+
+// packages/cms/dist/esm/widgets/scaffolding/datacolumns.js
+import { CustomElement as CustomElement12, P as P13, PCSS as PCSS8, Defaults as Defaults7, Watch as Watch12, PropertyConverters as PropertyConverters12, ViewChild as ViewChild6, Utils as Utils10, Components as Components2, UI as UI3 } from "@pacem/pacem-core";
+import { Components as ScaffoldingComponents3 } from "@pacem/pacem-scaffolding";
+var __decorate14 = 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 DATACOLUMNS_METADATA_TYPE = (host, hostRef = ":host", hostEntityRef = ":host.entity") => {
+  const attrs = {}, meta = host.metadata, fns = Functions, fnKeys = [];
+  attrs["properties"] = `{{ Pacem.CustomElementUtils.getWatchedProperty(${hostEntityRef}, '${meta.prop}').config.converter }}`;
+  const tagName = P13 + "-datacolumns";
+  let extra = meta.extra || {};
+  if (!Utils10.isNullOrEmpty(extra.properties)) {
+    switch (typeof extra.properties) {
+      case "string":
+        attrs["properties"] = `{{ ${hostEntityRef}.${extra.properties} }}`;
+        break;
+      case "function":
+        const fnKey = "fn" + Utils10.uniqueCode();
+        fns[fnKey] = extra.properties;
+        attrs["properties"] = `{{ Pacem.Components.Cms.Functions.${fnKey}(${hostRef}), once }}`;
+        fnKeys.push(fnKey);
+        break;
+    }
+  }
+  if (fnKeys.length > 0) {
+    attrs["on-unload"] = `{{ Pacem.Components.Cms.Functions.dismiss('${fnKeys.join("','")}') }}`;
+  }
+  return { tagName, attrs };
+};
+var DATACOLUMN_METADATA = {
+  display: { name: "Columns" },
+  props: [
+    { prop: "header", type: "string", display: { cssClass: ["form-minimal"], name: "Header" } },
+    {
+      prop: "content",
+      type: EXPRESSION_METADATA_TYPE,
+      display: { name: "Content" },
+      extra: EXPRESSION_WIDGET_METADATA_EXTRA
+    }
+  ]
+};
+var PacemDataColumnElement = class PacemDataColumnElement2 extends Components2.PacemElement {
+  propertyChangedCallback(name, old, val, first) {
+    super.propertyChangedCallback(name, old, val, first);
+    switch (name) {
+      case "content":
+        this.contentExpression = val;
+        break;
+      case "contentExpression":
+        this.setAttribute("content", val || "");
+        break;
+    }
+  }
+  viewActivatedCallback() {
+    super.viewActivatedCallback();
+    this._form.entity = this;
+    this._form.metadata = gridifyMetadata(DATACOLUMN_METADATA);
+  }
+};
+__decorate14([
+  Watch12({ converter: PropertyConverters12.String })
+], PacemDataColumnElement.prototype, "header", void 0);
+__decorate14([
+  Watch12({ converter: PropertyConverters12.String })
+], PacemDataColumnElement.prototype, "content", void 0);
+__decorate14([
+  Watch12({ converter: PropertyConverters12.String })
+], PacemDataColumnElement.prototype, "contentExpression", void 0);
+__decorate14([
+  ViewChild6(P13 + "-form")
+], PacemDataColumnElement.prototype, "_form", void 0);
+PacemDataColumnElement = __decorate14([
+  CustomElement12({
+    tagName: P13 + "-widget-datacolumn",
+    shadow: Defaults7.USE_SHADOW_ROOT,
+    template: `<${P13}-form class="panel-body" autogenerate="true"></${P13}-form>`
+  })
+], PacemDataColumnElement);
+var PacemDataColumnsElement = class PacemDataColumnsElement2 extends ScaffoldingComponents3.Scaffolding.PacemBaseElement {
+  constructor() {
+    super(...arguments);
+    this._dropHandler = (e) => {
+      this.changeHandler(e);
+    };
+    this._columnifyMetadata = (props = this.properties) => {
+      return (props || []).map((p) => {
+        const header = typeof p.display?.name === "function" ? (
+          /* NOT supported */
+          p.prop
+        ) : p.display?.name || p.prop;
+        const c = {
+          header,
+          content: `{{ ^item.${p.prop} }}`
+        };
+        return c;
+      }).sort((a, b) => a.header > b.header ? 1 : -1);
+    };
+  }
+  get inputFields() {
+    return [];
+  }
+  toggleReadonlyView(readonly) {
+  }
+  onChange(evt) {
+    return Utils10.fromResult(this.value = this._repeater.datasource);
+  }
+  acceptValue(val) {
+    if (!Utils10.isNull(this._repeater)) {
+      this._repeater.datasource = Utils10.clone(val || []);
+    }
+  }
+  getViewValue(value) {
+    return (
+      /* dummy */
+      "[DataColumns]"
+    );
+  }
+  convertValueAttributeToProperty(attr) {
+    return PropertyConverters12.Json.convert(attr, this);
+  }
+  viewActivatedCallback() {
+    super.viewActivatedCallback();
+    this._propDragger.addEventListener(UI3.DragDropEventType.End, this._dropHandler, false);
+    this._colDragger.addEventListener(UI3.DragDropEventType.End, this._dropHandler, false);
+  }
+  disconnectedCallback() {
+    if (!Utils10.isNull(this._propDragger)) {
+      this._propDragger.removeEventListener(UI3.DragDropEventType.End, this._dropHandler, false);
+    }
+    if (!Utils10.isNull(this._colDragger)) {
+      this._colDragger.removeEventListener(UI3.DragDropEventType.End, this._dropHandler, false);
+    }
+    super.disconnectedCallback();
+  }
+};
+__decorate14([
+  ViewChild6(`${P13}-repeater[columns]`)
+], PacemDataColumnsElement.prototype, "_repeater", void 0);
+__decorate14([
+  ViewChild6(`${P13}-drag-drop[properties]`)
+], PacemDataColumnsElement.prototype, "_propDragger", void 0);
+__decorate14([
+  ViewChild6(`${P13}-drag-drop[columns]`)
+], PacemDataColumnsElement.prototype, "_colDragger", void 0);
+__decorate14([
+  ViewChild6("div[drop-target]")
+], PacemDataColumnsElement.prototype, "_dropTarget", void 0);
+__decorate14([
+  Watch12({ converter: PropertyConverters12.Json })
+], PacemDataColumnsElement.prototype, "properties", void 0);
+PacemDataColumnsElement = __decorate14([
+  CustomElement12({
+    tagName: P13 + "-widget-datacolumns",
+    shadow: Defaults7.USE_SHADOW_ROOT,
+    template: `<div class="${PCSS8}-datacolumns">
+    <div class="datacolumns-main display-flex flex-fill">
+
+        <${P13}-drag-drop mode="${UI3.DragDataMode.Alias}" disabled="{{ :host.readonly }}" handle-selector="*[handle]"
+              drop-behavior="${UI3.DropBehavior.InsertChild}" drop-targets="{{ [::_dropTarget] }}" columns></${P13}-drag-drop>
+        <${P13}-repeater class="display-flex flex-fill" columns>
+            <!-- columns -->
+            <div class="display-flex flex-nowrap" drop-target>
+                <template>
+                    <${P13}-panel behaviors="{{ [::_colDragger] }}">
+                        <div class="${PCSS8}-panel panel-side-left side-auto">
+                            <div class="panel-side">
+                                <${P13}-button class="display-block button-flat icon-glyph-small" icon-glyph="drag_indicator" handle></${P13}-button>
+                                <${P13}-button class="display-block button-flat icon-glyph-small" on-click=":host.value.splice(^index, 1)" icon-glyph="clear"></${P13}-button>
+                            </div>
+                            <div class="panel-heading">
+                                <${P13}-text text="{{ ^item.header }}"></${P13}-text>
+                            </div>
+                            <${P13}-widget-datacolumn class="panel-body" header="{{ ^item.header, twoway }}" content-expression="{{ ^item.content, twoway }}"></${P13}-widget-datacolumn>
+                        </div>
+                    </${P13}-panel>
+                </template>
+            </div>
+        </${P13}-repeater>
+
+    </div>
+    <${P13}-panel class="datacolumns-props" hide="{{ :host.readonly }}">
+        <${P13}-drag-drop mode="${UI3.DragDataMode.Copy}" disabled="{{ :host.readonly }}" handle-selector="*[handle]"
+              drop-behavior="${UI3.DropBehavior.InsertChild}" drop-targets="{{ [::_dropTarget] }}" properties></${P13}-drag-drop>
+        <${P13}-repeater datasource="{{ :host._columnifyMetadata(:host.properties) }}">
+        <!-- properties -->
+            <template>
+                <${P13}-panel behaviors="{{ [::_propDragger] }}" class="${PCSS8}-panel panel-side-left side-auto panel-primary panel-filled ${PCSS8}-margin margin-bottom-1">
+                    <div class="panel-side">
+                        <${P13}-button class="display-block button-flat icon-glyph-small" icon-glyph="drag_indicator" handle></${P13}-button>
+                    </div>
+                    <div class="text-truncate panel-body">
+                        <${P13}-span text="{{ ^item.header }}"></${P13}-span>
+                    </div>
+                </${P13}-panel>
+            </template>
+        </${P13}-repeater>
+    </${P13}-panel>
+</div>`
+  })
+], PacemDataColumnsElement);
+
+// packages/cms/dist/esm/widgets/ui/dataviz/datagrid.js
+var __decorate15 = 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 DATACOLUMN_METADATA2 = {
+  display: { name: "DataColumn" },
+  props: [
+    { prop: "header", type: "string", display: { name: "Header" } },
+    { prop: "content", type: EXPRESSION_METADATA_TYPE, display: { name: "Content" }, extra: EXPRESSION_WIDGET_METADATA_EXTRA }
+  ]
+};
+var DATAGRID_METADATA = buildWidgetMetadata({
+  display: { icon: "table_chart", name: "DataGrid", description: "DataGrid widget." },
+  props: [
+    {
+      prop: "datasource",
+      type: EXPRESSION_METADATA_TYPE,
+      display: { name: "Datasource" },
+      extra: Utils11.extend({}, EXPRESSION_WIDGET_METADATA_EXTRA, { filter: (e) => e instanceof PacemWidgetDataElement || e instanceof PacemWidgetFetchElement })
+    },
+    {
+      prop: "columns",
+      type: DATACOLUMNS_METADATA_TYPE,
+      display: { name: "Columns" },
+      // this will include 'datasource' as argument in the oneToMany source fn
+      extra: { properties: "datarowMetadata" },
+      props: gridifyMetadata(DATACOLUMN_METADATA2)
+    }
+  ]
+});
+function gridify(columns = []) {
+  var output = "";
+  for (let column of columns || []) {
+    const col = column.width || 1;
+    if (typeof col === "number") {
+      output += col + "fr ";
+    } else {
+      output += "auto ";
+    }
+  }
+  return output;
+}
+function datagridFragments(columns = []) {
+  const fragHeading = document.createDocumentFragment(), fragBody = document.createDocumentFragment();
+  let j = 1;
+  for (let col of columns) {
+    const headcell = document.createElement("div");
+    headcell.classList.add(PCSS9 + "-headcell");
+    headcell.textContent = col.header;
+    fragHeading.appendChild(headcell);
+    const datacell = new Components3.PacemSpanElement();
+    datacell.classList.add(PCSS9 + "-datacell", "datacell-corners");
+    datacell.style.gridColumn = j.toString();
+    datacell.setAttribute("css", "{{ {'grid-row': ^index+2} }}");
+    datacell.setAttribute("content", col.content);
+    fragBody.appendChild(datacell);
+    j++;
+  }
+  const datarow = new Components3.PacemPanelElement();
+  datarow.classList.add(PCSS9 + "-datarow");
+  datarow.setAttribute("css", "{{ {'grid-row': ^index+2} }}");
+  datarow.setAttribute("css-class", "{{ {'datarow-alt': ^index % 2 === 1} }}");
+  datarow.style.gridColumn = "1/" + (columns.length + 1);
+  fragBody.appendChild(datarow);
+  return { head: fragHeading, body: fragBody };
+}
+function datagridInnerHTML(id, columns = []) {
+  const { head, body } = datagridFragments(columns);
+  const head0 = document.createElement("div");
+  head0.appendChild(head);
+  const body0 = document.createElement("div");
+  body0.appendChild(body);
+  return `<${P14}-repeater datasource="{{ #${id}.datasource }}">
+    <div class="${PCSS9}-datatable" style="grid-template-columns: ${gridify(columns)}">
+    ${head0.innerHTML}
+    <template>${body0.innerHTML}</template>
+</div></${P14}-repeater>`;
+}
+var PacemWidgetDataGridElement = class PacemWidgetDataGridElement2 extends PacemUiWidgetElement {
+  constructor() {
+    super(DATAGRID_METADATA);
+    this.columns = [];
+    this.datasource = [];
+    this.datarowMetadata = [];
+    this._builtUponDatasource = false;
+  }
+  _gridify(columns = this.columns) {
+    var output = "";
+    for (let column of columns || []) {
+      const col = column.width || 1;
+      if (typeof col === "number") {
+        output += col + "fr ";
+      } else {
+        output += "auto ";
+      }
+    }
+    return output;
+  }
+  propertyChangedCallback(name, old, val, first) {
+    super.propertyChangedCallback(name, old, val, first);
+    if (!first) {
+      switch (name) {
+        case "columns":
+          this.innerHTML = datagridInnerHTML(this.id, val);
+          break;
+        case "datasource":
+          this._extractMetadataJustInCase(val);
+          break;
+      }
+    }
+  }
+  viewActivatedCallback() {
+    super.viewActivatedCallback();
+    this.innerHTML = datagridInnerHTML(this.id, this.columns);
+  }
+  _seekArray(ds) {
+    if (Utils11.isArray(ds)) {
+      return ds;
+    }
+    if (typeof ds === "object") {
+      for (let prop in ds) {
+        const arr = this._seekArray(ds[prop]);
+        if (!Utils11.isNull(arr)) {
+          return arr;
+        }
+      }
+    }
+    return null;
+  }
+  _extractMetadataJustInCase(ds = this.datasource) {
+    if ((Utils11.isNullOrEmpty(this.datarowMetadata) || this._builtUponDatasource) && !Utils11.isNullOrEmpty(ds)) {
+      const arr = this._seekArray(ds);
+      if (!Utils11.isNullOrEmpty(arr)) {
+        const props = [];
+        const item = arr[0];
+        for (let prop in item) {
+          props.push({ prop, type: typeof item[prop] });
+        }
+        this.datarowMetadata = props;
+        this._builtUponDatasource = true;
+      }
+    }
+  }
+};
+__decorate15([
+  Watch13({ reflectBack: true, converter: PropertyConverters13.Json })
+], PacemWidgetDataGridElement.prototype, "columns", void 0);
+__decorate15([
+  Watch13({ converter: PropertyConverters13.Json })
+], PacemWidgetDataGridElement.prototype, "datasource", void 0);
+__decorate15([
+  Watch13({ converter: PropertyConverters13.Json })
+], PacemWidgetDataGridElement.prototype, "datarowMetadata", void 0);
+__decorate15([
+  ViewChild7(`.${PCSS9}-datatable`)
+], PacemWidgetDataGridElement.prototype, "_datatable", void 0);
+__decorate15([
+  ViewChild7("template")
+], PacemWidgetDataGridElement.prototype, "_template", void 0);
+__decorate15([
+  ViewChild7(P14 + "-repeater")
+], PacemWidgetDataGridElement.prototype, "_repeater", void 0);
+PacemWidgetDataGridElement = __decorate15([
+  CustomElement13({
+    tagName: P14 + "-widget-datagrid"
+  })
+], PacemWidgetDataGridElement);
+
+// packages/cms/dist/esm/index.cms.js
+var index_cms_exports = {};
+__export(index_cms_exports, {
+  DATACOLUMNS_METADATA_TYPE: () => DATACOLUMNS_METADATA_TYPE,
+  OpenApi: () => swagger_cms_exports,
+  PacemDataColumnElement: () => PacemDataColumnElement,
+  PacemDataColumnsElement: () => PacemDataColumnsElement,
+  Permissible: () => Permissible,
+  PermissionEditEvent: () => PermissionEditEvent,
+  PermissionEditEventName: () => PermissionEditEventName
+});
+
+// packages/cms/dist/esm/types.js
+import { Utils as Utils12 } from "@pacem/pacem-core";
+var PermissionEditEventName = "permissionedit";
+var PermissionEditEvent = class extends CustomEvent {
+  constructor(permissible) {
+    super(PermissionEditEventName, { detail: permissible, cancelable: false, bubbles: true });
+  }
+};
+var Permissible = class {
+  static canEdit(claims, resource) {
+    return this._canDoSomethingToResource(claims, resource, (p) => p.update);
+  }
+  static canRead(claims, resource) {
+    return this._canDoSomethingToResource(claims, resource, (p) => p.read);
+  }
+  static canAdd(claims, resource) {
+    return this._canDoSomethingToResource(claims, resource, (p) => p.create);
+  }
+  static canDelete(claims, resource) {
+    return this._canDoSomethingToResource(claims, resource, (p) => p.delete);
+  }
+  static canTranslate(claims, resource) {
+    return this._canDoSomethingToResource(claims, resource, (p) => p.translate);
+  }
+  static _canDoSomethingToResource(claims, resource, predicate) {
+    if (Utils12.isNullOrEmpty(claims) || Utils12.isNull(resource)) {
+      return false;
+    }
+    var editable = true;
+    if (resource.permissions && resource.permissions.length > 0) {
+      editable = false;
+      for (let permission of resource.permissions) {
+        if (predicate(permission) && claims[permission.claimType] && claims[permission.claimType].indexOf(permission.claimValue) >= 0) {
+          return true;
+        }
+      }
+    }
+    return editable;
+  }
+};
+export {
+  index_cms_exports as Cms,
+  index_components_exports as Components
+};
+//# sourceMappingURL=pacem-cms.mjs.map