@pequity/squirrel 1.0.20-beta.3 → 1.0.20

package/dist/cjs/p-drawer.js

@@ -1,253 +0,0 @@
-"use strict";
-const pAlert = require("./p-alert.js");
-const pCloseBtn = require("./p-close-btn.js");
-const vue = require("vue");
-const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
-const _sfc_main = vue.defineComponent({
-  name: "PDrawer",
-  components: {
-    PAlert: pAlert,
-    PCloseBtn: pCloseBtn
-  },
-  props: {
-    appendTo: {
-      type: String,
-      default: "body"
-    },
-    title: {
-      type: String,
-      default: ""
-    },
-    disabled: {
-      type: Boolean,
-      default: false
-    },
-    errorMsg: {
-      type: String,
-      default: ""
-    },
-    position: {
-      type: String,
-      default: "right"
-    },
-    zIndex: {
-      type: Number,
-      default: 900
-    },
-    drawerStyle: {
-      type: Object,
-      default: () => ({})
-    },
-    drawerClass: {
-      type: String,
-      default: "drawer"
-    },
-    inClass: {
-      type: String,
-      default: ""
-    },
-    outClass: {
-      type: String,
-      default: ""
-    },
-    live: {
-      type: Boolean,
-      default: false
-    },
-    modelValue: {
-      type: Boolean,
-      default: false
-    },
-    closeLabel: {
-      type: String,
-      default: "Close"
-    },
-    showBackdrop: {
-      type: Boolean,
-      default: false
-    },
-    enableClose: {
-      type: Boolean,
-      default: true
-    }
-  },
-  emits: ["update:modelValue", "before-open", "opening", "opened", "before-close", "closing", "closed"],
-  data() {
-    return {
-      id: null,
-      show: false,
-      mount: false
-    };
-  },
-  computed: {
-    transitionInClass() {
-      return this.inClass || this.position === "right" ? "slideInRight" : "slideInLeft";
-    },
-    transitionOutClass() {
-      return this.outClass || this.position === "right" ? "slideOutRight" : "slideOutLeft";
-    }
-  },
-  created() {
-    if (this.live) {
-      this.mount = true;
-    }
-  },
-  mounted() {
-    this.id = "drawer-" + this.$.uid;
-    this.$watch(
-      "modelValue",
-      (newVal) => {
-        if (newVal) {
-          this.mount = true;
-          this.$nextTick(() => {
-            this.show = true;
-          });
-        } else {
-          this.show = false;
-        }
-      },
-      { immediate: true }
-    );
-  },
-  methods: {
-    close() {
-      if (this.enableClose === true) {
-        this.$emit("update:modelValue", false);
-      }
-    },
-    beforeOpen() {
-      this.$emit("before-open");
-    },
-    opening() {
-      this.$emit("opening");
-    },
-    opened() {
-      this.$emit("opened");
-    },
-    beforeClose() {
-      this.$emit("before-close");
-    },
-    closing() {
-      this.$emit("closing");
-    },
-    closed() {
-      if (!this.live) {
-        this.mount = false;
-      }
-      this.$nextTick(() => {
-        this.$emit("closed");
-      });
-    }
-  }
-});
-const _hoisted_1 = ["data-drawer-id", "aria-label", "aria-describedby", "aria-labelledby"];
-const _hoisted_2 = ["id"];
-const _hoisted_3 = {
-  key: 0,
-  class: "px-6 pt-6"
-};
-const _hoisted_4 = { class: "whitespace-pre-line" };
-const _hoisted_5 = { class: "footer p-6" };
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_PCloseBtn = vue.resolveComponent("PCloseBtn");
-  const _component_PAlert = vue.resolveComponent("PAlert");
-  return _ctx.mount ? (vue.openBlock(), vue.createBlock(vue.Teleport, {
-    key: 0,
-    to: _ctx.appendTo
-  }, [
-    vue.createVNode(vue.Transition, {
-      name: "pd-backdrop-transition",
-      "enter-active-class": "fadeIn",
-      "leave-active-class": "fadeOut"
-    }, {
-      default: vue.withCtx(() => [
-        vue.withDirectives(vue.createElementVNode("div", {
-          class: vue.normalizeClass(["fixed bottom-0 left-0 right-0 top-0 bg-black bg-opacity-20", { "cursor-pointer": _ctx.enableClose }]),
-          style: vue.normalizeStyle({ "z-index": _ctx.zIndex - 1 }),
-          tabindex: "-1",
-          onClick: _cache[0] || (_cache[0] = (...args) => _ctx.close && _ctx.close(...args))
-        }, null, 6), [
-          [vue.vShow, _ctx.show && _ctx.showBackdrop]
-        ])
-      ]),
-      _: 1
-    }),
-    vue.createVNode(vue.Transition, {
-      name: "drawer-transition",
-      "enter-active-class": _ctx.transitionInClass,
-      "leave-active-class": _ctx.transitionOutClass,
-      onBeforeEnter: _ctx.beforeOpen,
-      onEnter: _ctx.opening,
-      onAfterEnter: _ctx.opened,
-      onBeforeLeave: _ctx.beforeClose,
-      onLeave: _ctx.closing,
-      onAfterLeave: _ctx.closed
-    }, {
-      default: vue.withCtx(() => [
-        vue.withDirectives(vue.createElementVNode("div", {
-          "data-drawer-id": _ctx.id,
-          tabindex: "-1",
-          class: vue.normalizeClass([_ctx.drawerClass, _ctx.position === "right" ? "drawer-right" : "drawer-left"]),
-          style: vue.normalizeStyle({ "z-index": _ctx.zIndex, ..._ctx.drawerStyle }),
-          role: "dialog",
-          "aria-label": _ctx.title,
-          "aria-modal": "false",
-          "aria-describedby": `${_ctx.id}-content`,
-          "aria-labelledby": `${_ctx.id}-title`
-        }, [
-          vue.renderSlot(_ctx.$slots, "title-wrapper", {}, () => [
-            vue.createElementVNode("div", {
-              class: vue.normalizeClass([
-                "flex items-center border-b border-p-gray-30 px-6 pb-4 pt-4",
-                { "flex-row-reverse": _ctx.position === "right" }
-              ])
-            }, [
-              _ctx.enableClose ? (vue.openBlock(), vue.createBlock(_component_PCloseBtn, {
-                key: 0,
-                "aria-label": _ctx.closeLabel,
-                class: "flex-0",
-                disabled: _ctx.disabled,
-                onClick: _ctx.close
-              }, null, 8, ["aria-label", "disabled", "onClick"])) : vue.createCommentVNode("", true),
-              vue.renderSlot(_ctx.$slots, "title", {}, () => [
-                _ctx.title ? (vue.openBlock(), vue.createElementBlock("h3", {
-                  key: 0,
-                  id: `${_ctx.id}-title`,
-                  class: vue.normalizeClass(["flex-1 text-xl font-medium", { "text-right": _ctx.position === "left" }])
-                }, vue.toDisplayString(_ctx.title), 11, _hoisted_2)) : vue.createCommentVNode("", true)
-              ], true)
-            ], 2)
-          ], true),
-          _ctx.errorMsg ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3, [
-            vue.createVNode(_component_PAlert, { type: "error" }, {
-              default: vue.withCtx(() => [
-                vue.createElementVNode("div", _hoisted_4, vue.toDisplayString(_ctx.errorMsg), 1)
-              ]),
-              _: 1
-            })
-          ])) : vue.createCommentVNode("", true),
-          vue.renderSlot(_ctx.$slots, "content-wrapper", {}, () => [
-            vue.createElementVNode("div", {
-              class: vue.normalizeClass([
-                "relative grow overflow-y-auto overflow-x-hidden px-6 pt-6",
-                { "pointer-events-none opacity-50": _ctx.disabled }
-              ])
-            }, [
-              vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
-            ], 2)
-          ], true),
-          vue.renderSlot(_ctx.$slots, "footer-wrapper", {}, () => [
-            vue.createElementVNode("div", _hoisted_5, [
-              vue.renderSlot(_ctx.$slots, "footer", {}, void 0, true)
-            ])
-          ], true)
-        ], 14, _hoisted_1), [
-          [vue.vShow, _ctx.show]
-        ])
-      ]),
-      _: 3
-    }, 8, ["enter-active-class", "leave-active-class", "onBeforeEnter", "onEnter", "onAfterEnter", "onBeforeLeave", "onLeave", "onAfterLeave"])
-  ], 8, ["to"])) : vue.createCommentVNode("", true);
-}
-const pDrawer = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-a0b8be1e"]]);
-module.exports = pDrawer;

package/dist/cjs/p-dropdown-select.js

@@ -1,3 +0,0 @@
-"use strict";
-const pDropdownSelect_vue_vue_type_script_setup_true_lang = require("./chunks/p-dropdown-select.js");
-module.exports = pDropdownSelect_vue_vue_type_script_setup_true_lang._sfc_main;

package/dist/cjs/p-dropdown.js

@@ -1,138 +0,0 @@
-"use strict";
-const listKeyboardNavigation = require("./listKeyboardNavigation.js");
-const vue = require("vue");
-const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
-const ESCAPE_KEY = "Escape";
-const _sfc_main = vue.defineComponent({
-  name: "PDropdown",
-  inheritAttrs: false,
-  props: {
-    /**
-     * Enables navigation for `.dropdown-item` using the up/down keys.
-     * This can be set to false when we're creating a generic popover.
-     */
-    enableArrowNavigation: {
-      type: Boolean,
-      default: true
-    },
-    /**
-     * Enables closing the dropdown with the Escape key.
-     */
-    enableCloseOnEsc: {
-      type: Boolean,
-      default: true
-    },
-    /**
-     * The selector that the arrow navigation function will use to
-     * match the items in the list.
-     */
-    itemSelector: {
-      type: String,
-      default: ".dropdown-item:not(.disabled), .dropdown-item:not(:disabled)"
-    },
-    /**
-     * The CSS class of the "focused" dropdown item
-     */
-    itemFocusClass: {
-      type: String,
-      default: "focus"
-    },
-    /**
-     * v-tooltip wraps the popper trigger with a div that has `display: inline-block` set by default.
-     * This prop is used to override the CSS style of that wrapper div
-     */
-    triggerStyle: {
-      type: Object,
-      default: () => ({
-        display: "inline-block"
-      })
-    },
-    /**
-     * Custom reference element that is used to position the popper.
-     * Can be changed at runtime to create a dynamically positioned dropdown.
-     */
-    reference: {
-      type: HTMLElement,
-      default: null
-    }
-  },
-  data() {
-    return {
-      defaultAttrs: {
-        triggers: ["click"],
-        "auto-hide": true,
-        theme: "p-dropdown-theme",
-        "popper-class": "dropdown",
-        placement: "bottom-start",
-        distance: 4,
-        delay: 0,
-        handleResize: true
-      },
-      navigationSvc: null
-    };
-  },
-  watch: {
-    reference: {
-      async handler(nV, oV) {
-        if (nV && oV !== nV) {
-          const popper = this.$refs.vPopper.$refs.popper;
-          if (popper) {
-            popper.$_detachPopperNode();
-            if (popper.shown) {
-              popper.hide({ skipDelay: true });
-            }
-            if (this.reference) {
-              popper.$_referenceNode = this.reference;
-            }
-          }
-        }
-      }
-    }
-  },
-  mounted() {
-    Object.assign(this.$refs.vPopper.$refs.popper.$el.style, this.triggerStyle);
-  },
-  beforeUnmount() {
-    this.destroy();
-  },
-  methods: {
-    onShow() {
-      if (this.enableArrowNavigation) {
-        if (this.navigationSvc) {
-          this.navigationSvc.init();
-        } else {
-          this.navigationSvc = listKeyboardNavigation.setupListKeyboardNavigation({
-            itemContainer: this.$refs.vPopper.$refs.popperContent.$el
-          });
-        }
-      }
-      this.enableCloseOnEsc && document.addEventListener("keydown", this.popoverEscKeydown);
-    },
-    popoverEscKeydown(e) {
-      e.key === ESCAPE_KEY && this.$refs.vPopper.$refs.popper.hide();
-    },
-    destroy() {
-      var _a;
-      (_a = this.navigationSvc) == null ? void 0 : _a.destroy();
-      document.removeEventListener("keydown", this.popoverEscKeydown);
-    }
-  }
-});
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_VDropdown = vue.resolveComponent("VDropdown");
-  return vue.openBlock(), vue.createBlock(_component_VDropdown, vue.mergeProps({ ref: "vPopper" }, { ..._ctx.defaultAttrs, ..._ctx.$attrs }, {
-    onShow: _ctx.onShow,
-    onHide: _ctx.destroy
-  }), vue.createSlots({ _: 2 }, [
-    vue.renderList(_ctx.$slots, (_, slot) => {
-      return {
-        name: slot,
-        fn: vue.withCtx((scope) => [
-          vue.renderSlot(_ctx.$slots, slot, vue.normalizeProps(vue.guardReactiveProps(scope || {})))
-        ])
-      };
-    })
-  ]), 1040, ["onShow", "onHide"]);
-}
-const PDropdown = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render]]);
-module.exports = PDropdown;

package/dist/cjs/p-file-upload.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const getFileExtension = (fileName) => {
-  var _a;
-  if (!fileName || !fileName.includes(".")) {
-    return "";
-  }
-  return (_a = fileName.split(".").pop()) == null ? void 0 : _a.toLowerCase();
-};
-const formatBytes = (bytes, decimals = 2) => {
-  if (!+bytes || bytes <= 0) {
-    return "0 B";
-  }
-  const k = 1e3;
-  const dm = decimals < 0 ? 0 : decimals;
-  const sizes = ["B", "KB", "MB", "GB", "TB", "PB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
-};
-exports.formatBytes = formatBytes;
-exports.getFileExtension = getFileExtension;

package/dist/cjs/p-info-icon.js

@@ -1,35 +0,0 @@
-"use strict";
-const vue = require("vue");
-const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
-const _withScopeId = (n) => (vue.pushScopeId("data-v-189b159e"), n = n(), vue.popScopeId(), n);
-const _hoisted_1 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ vue.createElementVNode("i", { class: "bg-info-circle-icon block h-3 w-3" }, null, -1));
-const _sfc_main = /* @__PURE__ */ vue.defineComponent({
-  ...{
-    name: "PInfoIcon"
-  },
-  __name: "p-info-icon",
-  props: {
-    text: {
-      type: String,
-      default: ""
-    }
-  },
-  setup(__props) {
-    return (_ctx, _cache) => {
-      const _component_VTooltip = vue.resolveComponent("VTooltip");
-      return vue.openBlock(), vue.createBlock(_component_VTooltip, null, {
-        popper: vue.withCtx(() => [
-          vue.renderSlot(_ctx.$slots, "default", {}, () => [
-            vue.createTextVNode(vue.toDisplayString(__props.text), 1)
-          ], true)
-        ]),
-        default: vue.withCtx(() => [
-          _hoisted_1
-        ]),
-        _: 3
-      });
-    };
-  }
-});
-const PInfoIcon = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-189b159e"]]);
-module.exports = PInfoIcon;

package/dist/cjs/p-inline-date-picker.js

@@ -1,142 +0,0 @@
-"use strict";
-const dayjs = require("dayjs");
-const inputClassesMixin = require("./inputClassesMixin.js");
-const vCalendar = require("v-calendar");
-const vue = require("vue");
-const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
-const selectAttribute = { highlight: { class: "bg-primary", contentClass: "text-white" } };
-const DEFAULT_MASKS = {
-  // The mask for the input
-  input: "DD-MMM-YYYY",
-  // The mask for the model value
-  data: "YYYY-MM-DD"
-};
-const _sfc_main = vue.defineComponent({
-  name: "PInlineDatePicker",
-  components: {
-    DatePicker: vCalendar.DatePicker
-  },
-  mixins: [inputClassesMixin],
-  inheritAttrs: false,
-  props: {
-    modelValue: {
-      type: String,
-      default: ""
-    },
-    label: {
-      type: String,
-      default: ""
-    },
-    errorMsg: {
-      type: String,
-      default: ""
-    },
-    required: {
-      type: Boolean,
-      default: false
-    },
-    minDate: {
-      type: Date,
-      default: null
-    },
-    maxDate: {
-      type: Date,
-      default: null
-    },
-    timezone: {
-      type: String,
-      default: ""
-    }
-  },
-  emits: ["update:modelValue"],
-  data() {
-    return {
-      // innerValue is a Date object
-      innerValue: null,
-      selectAttribute
-    };
-  },
-  computed: {
-    masks() {
-      return Object.assign(DEFAULT_MASKS, this.$attrs.masks);
-    },
-    attrs() {
-      const { class: classes, style, ...rest } = this.$attrs;
-      return rest;
-    },
-    listeners() {
-      return Object.keys(this.$attrs).reduce((acc, curr) => {
-        if (curr.startsWith("on")) {
-          return { ...acc, [curr]: this.$attrs[curr] };
-        } else {
-          return acc;
-        }
-      }, {});
-    },
-    style() {
-      return this.$attrs.style;
-    },
-    styleDatepicker() {
-      return this.errorMsg ? { border: "1px solid var(--color-on-error)" } : {};
-    }
-  },
-  watch: {
-    modelValue: {
-      handler(nV) {
-        const date = dayjs(nV, this.masks.data).toDate();
-        if (nV && date.toString() === "Invalid Date") {
-          this.$emit("update:modelValue", null);
-          return;
-        }
-        this.innerValue = nV ? dayjs(nV, this.masks.data).toDate() : null;
-        const datepicker = this.$refs.datepicker;
-        if (datepicker && this.innerValue) {
-          datepicker.move(this.innerValue);
-        }
-      },
-      immediate: true
-    }
-  },
-  methods: {
-    dayclick(e) {
-      this.$emit("update:modelValue", e.id);
-    }
-  }
-});
-const _hoisted_1 = ["data-has-error"];
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_DatePicker = vue.resolveComponent("DatePicker");
-  return vue.openBlock(), vue.createElementBlock("div", {
-    class: vue.normalizeClass([{ hidden: _ctx.$attrs.hidden }, _ctx.$attrs.class]),
-    "data-has-error": !!_ctx.errorMsg,
-    style: vue.normalizeStyle(_ctx.style)
-  }, [
-    vue.renderSlot(_ctx.$slots, "label", {
-      label: _ctx.label,
-      labelClasses: _ctx.labelClasses
-    }, () => [
-      _ctx.label ? (vue.openBlock(), vue.createElementBlock("label", {
-        key: 0,
-        class: vue.normalizeClass(_ctx.labelClasses)
-      }, vue.toDisplayString(_ctx.label), 3)) : vue.createCommentVNode("", true)
-    ]),
-    vue.createVNode(_component_DatePicker, vue.mergeProps({
-      ref: "datepicker",
-      class: { "pointer-events-none opacity-70": _ctx.$attrs.disabled },
-      "model-value": _ctx.innerValue,
-      "select-attribute": _ctx.selectAttribute,
-      "min-date": _ctx.minDate || null,
-      "max-date": _ctx.maxDate || null,
-      masks: _ctx.masks,
-      style: _ctx.styleDatepicker,
-      timezone: _ctx.timezone
-    }, _ctx.listeners, { onDayclick: _ctx.dayclick }), null, 16, ["class", "model-value", "select-attribute", "min-date", "max-date", "masks", "style", "timezone", "onDayclick"]),
-    vue.withDirectives(vue.createElementVNode("div", {
-      class: vue.normalizeClass(_ctx.errorMsgClasses)
-    }, vue.toDisplayString(_ctx.errorMsg), 3), [
-      [vue.vShow, _ctx.errorMsg]
-    ])
-  ], 14, _hoisted_1);
-}
-const pInlineDatePicker = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render]]);
-module.exports = pInlineDatePicker;