@pequity/squirrel 1.0.20 → 1.0.21

package/dist/es/p-drawer.js

@@ -0,0 +1,254 @@
+import PAlert from "./p-alert.js";
+import PCloseBtn from "./p-close-btn.js";
+import { defineComponent, resolveComponent, openBlock, createBlock, Teleport, createVNode, Transition, withCtx, withDirectives, createElementVNode, normalizeClass, normalizeStyle, vShow, renderSlot, createCommentVNode, createElementBlock, toDisplayString } from "vue";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _sfc_main = defineComponent({
+  name: "PDrawer",
+  components: {
+    PAlert,
+    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 = resolveComponent("PCloseBtn");
+  const _component_PAlert = resolveComponent("PAlert");
+  return _ctx.mount ? (openBlock(), createBlock(Teleport, {
+    key: 0,
+    to: _ctx.appendTo
+  }, [
+    createVNode(Transition, {
+      name: "pd-backdrop-transition",
+      "enter-active-class": "fadeIn",
+      "leave-active-class": "fadeOut"
+    }, {
+      default: withCtx(() => [
+        withDirectives(createElementVNode("div", {
+          class: normalizeClass(["fixed bottom-0 left-0 right-0 top-0 bg-black bg-opacity-20", { "cursor-pointer": _ctx.enableClose }]),
+          style: normalizeStyle({ "z-index": _ctx.zIndex - 1 }),
+          tabindex: "-1",
+          onClick: _cache[0] || (_cache[0] = (...args) => _ctx.close && _ctx.close(...args))
+        }, null, 6), [
+          [vShow, _ctx.show && _ctx.showBackdrop]
+        ])
+      ]),
+      _: 1
+    }),
+    createVNode(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: withCtx(() => [
+        withDirectives(createElementVNode("div", {
+          "data-drawer-id": _ctx.id,
+          tabindex: "-1",
+          class: normalizeClass([_ctx.drawerClass, _ctx.position === "right" ? "drawer-right" : "drawer-left"]),
+          style: 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`
+        }, [
+          renderSlot(_ctx.$slots, "title-wrapper", {}, () => [
+            createElementVNode("div", {
+              class: normalizeClass([
+                "flex items-center border-b border-p-gray-30 px-6 pb-4 pt-4",
+                { "flex-row-reverse": _ctx.position === "right" }
+              ])
+            }, [
+              _ctx.enableClose ? (openBlock(), createBlock(_component_PCloseBtn, {
+                key: 0,
+                "aria-label": _ctx.closeLabel,
+                class: "flex-0",
+                disabled: _ctx.disabled,
+                onClick: _ctx.close
+              }, null, 8, ["aria-label", "disabled", "onClick"])) : createCommentVNode("", true),
+              renderSlot(_ctx.$slots, "title", {}, () => [
+                _ctx.title ? (openBlock(), createElementBlock("h3", {
+                  key: 0,
+                  id: `${_ctx.id}-title`,
+                  class: normalizeClass(["flex-1 text-xl font-medium", { "text-right": _ctx.position === "left" }])
+                }, toDisplayString(_ctx.title), 11, _hoisted_2)) : createCommentVNode("", true)
+              ], true)
+            ], 2)
+          ], true),
+          _ctx.errorMsg ? (openBlock(), createElementBlock("div", _hoisted_3, [
+            createVNode(_component_PAlert, { type: "error" }, {
+              default: withCtx(() => [
+                createElementVNode("div", _hoisted_4, toDisplayString(_ctx.errorMsg), 1)
+              ]),
+              _: 1
+            })
+          ])) : createCommentVNode("", true),
+          renderSlot(_ctx.$slots, "content-wrapper", {}, () => [
+            createElementVNode("div", {
+              class: normalizeClass([
+                "relative grow overflow-y-auto overflow-x-hidden px-6 pt-6",
+                { "pointer-events-none opacity-50": _ctx.disabled }
+              ])
+            }, [
+              renderSlot(_ctx.$slots, "default", {}, void 0, true)
+            ], 2)
+          ], true),
+          renderSlot(_ctx.$slots, "footer-wrapper", {}, () => [
+            createElementVNode("div", _hoisted_5, [
+              renderSlot(_ctx.$slots, "footer", {}, void 0, true)
+            ])
+          ], true)
+        ], 14, _hoisted_1), [
+          [vShow, _ctx.show]
+        ])
+      ]),
+      _: 3
+    }, 8, ["enter-active-class", "leave-active-class", "onBeforeEnter", "onEnter", "onAfterEnter", "onBeforeLeave", "onLeave", "onAfterLeave"])
+  ], 8, ["to"])) : createCommentVNode("", true);
+}
+const pDrawer = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-a0b8be1e"]]);
+export {
+  pDrawer as default
+};

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

@@ -0,0 +1,4 @@
+import { a as _sfc_main } from "./chunks/p-dropdown-select.js";
+export {
+  _sfc_main as default
+};

package/dist/es/p-dropdown.js

@@ -0,0 +1,139 @@
+import { setupListKeyboardNavigation } from "./listKeyboardNavigation.js";
+import { defineComponent, resolveComponent, openBlock, createBlock, mergeProps, createSlots, renderList, withCtx, renderSlot, normalizeProps, guardReactiveProps } from "vue";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const ESCAPE_KEY = "Escape";
+const _sfc_main = 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 = 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 = resolveComponent("VDropdown");
+  return openBlock(), createBlock(_component_VDropdown, mergeProps({ ref: "vPopper" }, { ..._ctx.defaultAttrs, ..._ctx.$attrs }, {
+    onShow: _ctx.onShow,
+    onHide: _ctx.destroy
+  }), createSlots({ _: 2 }, [
+    renderList(_ctx.$slots, (_, slot) => {
+      return {
+        name: slot,
+        fn: withCtx((scope) => [
+          renderSlot(_ctx.$slots, slot, normalizeProps(guardReactiveProps(scope || {})))
+        ])
+      };
+    })
+  ]), 1040, ["onShow", "onHide"]);
+}
+const PDropdown = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  PDropdown as default
+};

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

@@ -0,0 +1,21 @@
+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]}`;
+};
+export {
+  formatBytes,
+  getFileExtension
+};

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

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

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

@@ -0,0 +1,143 @@
+import dayjs from "dayjs";
+import inputClassesMixin from "./inputClassesMixin.js";
+import { DatePicker } from "v-calendar";
+import { defineComponent, resolveComponent, openBlock, createElementBlock, normalizeClass, normalizeStyle, renderSlot, toDisplayString, createCommentVNode, createVNode, mergeProps, withDirectives, createElementVNode, vShow } from "vue";
+import { _ as _export_sfc } from "./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 = defineComponent({
+  name: "PInlineDatePicker",
+  components: {
+    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 = resolveComponent("DatePicker");
+  return openBlock(), createElementBlock("div", {
+    class: normalizeClass([{ hidden: _ctx.$attrs.hidden }, _ctx.$attrs.class]),
+    "data-has-error": !!_ctx.errorMsg,
+    style: normalizeStyle(_ctx.style)
+  }, [
+    renderSlot(_ctx.$slots, "label", {
+      label: _ctx.label,
+      labelClasses: _ctx.labelClasses
+    }, () => [
+      _ctx.label ? (openBlock(), createElementBlock("label", {
+        key: 0,
+        class: normalizeClass(_ctx.labelClasses)
+      }, toDisplayString(_ctx.label), 3)) : createCommentVNode("", true)
+    ]),
+    createVNode(_component_DatePicker, 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"]),
+    withDirectives(createElementVNode("div", {
+      class: normalizeClass(_ctx.errorMsgClasses)
+    }, toDisplayString(_ctx.errorMsg), 3), [
+      [vShow, _ctx.errorMsg]
+    ])
+  ], 14, _hoisted_1);
+}
+const pInlineDatePicker = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  pInlineDatePicker as default
+};