@expcat/tigercat-vue 1.1.0 → 1.2.14

package/dist/{chunk-ML2QP5KF.mjs → chunk-LILAZ4UJ.mjs}

@@ -1,7 +1,38 @@
-import { useTigerConfig } from './chunk-E3BSOB7P.mjs';
-import { defineComponent, ref, computed, watch, h } from 'vue';
-import { getSpinnerSVG, mergeTigerLocale, getUploadLabels, mergeStyleValues, classNames, coerceClassValue, getDragAreaClasses, interpolateUploadLabel, formatFileSize, getUploadButtonClasses, handleUploadDrop, handleUploadDragLeave, handleUploadDragOver, getPictureCardClasses, getUploadStatusIconClasses, normalizeSvgAttrs, getFileListItemClasses, icon20ViewBox, successCircleSolidIcon20PathD, errorCircleSolidIcon20PathD, closeSolidIcon20PathD, prepareUploadFiles, fileToUploadFile } from '@expcat/tigercat-core';
+import {
+  useTigerConfig
+} from "./chunk-VG6E4NX6.mjs";
 
+// src/components/Upload.ts
+import { defineComponent, ref, computed, watch, h } from "vue";
+import {
+  classNames,
+  coerceClassValue,
+  mergeStyleValues,
+  icon20ViewBox,
+  closeSolidIcon20PathD,
+  successCircleSolidIcon20PathD,
+  errorCircleSolidIcon20PathD,
+  getSpinnerSVG,
+  normalizeSvgAttrs,
+  getUploadLabels,
+  interpolateUploadLabel,
+  mergeTigerLocale,
+  prepareUploadFiles,
+  fileToUploadFile,
+  createUploadChunks,
+  createUploadQueueItem,
+  getUploadResumeKey,
+  runUploadQueue,
+  handleUploadDragOver,
+  handleUploadDragLeave,
+  handleUploadDrop,
+  formatFileSize,
+  getUploadButtonClasses,
+  getDragAreaClasses,
+  getFileListItemClasses,
+  getPictureCardClasses,
+  getUploadStatusIconClasses
+} from "@expcat/tigercat-core";
 var Upload = defineComponent({
   name: "TigerUpload",
   inheritAttrs: false,
@@ -93,6 +124,10 @@ var Upload = defineComponent({
       type: Boolean,
       default: true
     },
+    queue: { type: Boolean, default: false },
+    maxConcurrent: { type: Number, default: 2 },
+    chunkSize: { type: Number, default: void 0 },
+    resumable: { type: Boolean, default: false },
     /**
      * Custom upload request function
      */
@@ -150,6 +185,8 @@ var Upload = defineComponent({
      * Emitted on upload error
      */
     error: (error, _file) => error instanceof Error,
+    "chunk-progress": (_chunk, progress, _file) => typeof progress === "number",
+    "queue-change": (queue) => Array.isArray(queue),
     /**
      * Emitted when file limit is exceeded
      */
@@ -216,30 +253,100 @@ var Upload = defineComponent({
         nextFileList = [...nextFileList, uploadFile];
         setFileList(nextFileList);
         emit("change", uploadFile, nextFileList);
-        if (props.autoUpload) {
-          uploadFile.status = "uploading";
-          if (props.customRequest) {
-            props.customRequest({
-              file,
-              onProgress: (progress) => {
-                uploadFile.progress = progress;
-                emit("progress", progress, uploadFile);
-              },
-              onSuccess: (response) => {
-                uploadFile.status = "success";
-                emit("success", response, uploadFile);
-              },
-              onError: (error) => {
-                uploadFile.status = "error";
-                uploadFile.error = error.message;
-                emit("error", error, uploadFile);
-              }
-            });
-          } else {
-            uploadFile.status = "success";
-          }
+        if (props.autoUpload && !props.queue) {
+          await uploadOne(file, uploadFile, () => setFileList([...nextFileList]));
         }
       }
+      if (props.autoUpload && props.queue) {
+        const queueItems = prepared.acceptedFiles.map(
+          (file) => createUploadQueueItem(
+            file,
+            nextFileList.find((item) => item.file === file)?.uid,
+            props.chunkSize
+          )
+        );
+        emit("queue-change", queueItems);
+        await runUploadQueue(
+          queueItems,
+          async (item) => {
+            const uploadFile = nextFileList.find((candidate) => candidate.uid === item.id);
+            if (!uploadFile) return;
+            await uploadOne(item.file, uploadFile, () => setFileList([...nextFileList]));
+          },
+          { concurrency: props.maxConcurrent, onChange: (items) => emit("queue-change", items) }
+        );
+      }
+    };
+    const uploadOne = async (file, uploadFile, notify) => {
+      uploadFile.status = "uploading";
+      notify();
+      if (!props.customRequest) {
+        uploadFile.progress = 100;
+        uploadFile.status = "success";
+        notify();
+        return;
+      }
+      const chunks = props.chunkSize ? createUploadChunks(file, props.chunkSize) : [];
+      const resumeKey = props.resumable ? getUploadResumeKey(file) : void 0;
+      if (chunks.length <= 1) {
+        await requestUpload(file, uploadFile, notify, { resumeKey });
+        return;
+      }
+      for (const chunk of chunks) {
+        const chunkFile = new File([chunk.blob], file.name, {
+          type: file.type,
+          lastModified: file.lastModified
+        });
+        await requestUpload(chunkFile, uploadFile, notify, {
+          originalFile: file,
+          chunk,
+          totalChunks: chunks.length,
+          resumeKey
+        });
+      }
+      uploadFile.progress = 100;
+      uploadFile.status = "success";
+      emit("success", { chunks: chunks.length, resumeKey }, uploadFile);
+      notify();
+    };
+    const requestUpload = (file, uploadFile, notify, options) => {
+      return new Promise((resolve, reject) => {
+        props.customRequest?.({
+          file,
+          originalFile: options.originalFile,
+          chunk: options.chunk,
+          chunkIndex: options.chunk?.index,
+          totalChunks: options.totalChunks,
+          resumeKey: options.resumeKey,
+          onProgress: (progress) => {
+            const nextProgress = options.chunk ? Math.round(
+              (options.chunk.index + progress / 100) / (options.totalChunks ?? 1) * 100
+            ) : progress;
+            uploadFile.progress = nextProgress;
+            if (options.chunk) {
+              emit("chunk-progress", options.chunk, progress, uploadFile);
+            }
+            emit("progress", nextProgress, uploadFile);
+            notify();
+          },
+          onSuccess: (response) => {
+            if (!options.chunk) {
+              uploadFile.status = "success";
+              uploadFile.progress = 100;
+              emit("success", response, uploadFile);
+              notify();
+            }
+            resolve();
+          },
+          onError: (error) => {
+            uploadFile.status = "error";
+            uploadFile.error = error.message;
+            emit("error", error, uploadFile);
+            notify();
+            reject(error);
+          }
+        });
+      });
     };
     const handleRemove = (file) => {
       const newFileList = fileListValue.value.filter((f) => f.uid !== file.uid);
@@ -623,4 +730,7 @@ var Upload = defineComponent({
 });
 var Upload_default = Upload;
 
-export { Upload, Upload_default };
+export {
+  Upload,
+  Upload_default
+};

package/dist/chunk-LL4ASJ4O.mjs

@@ -1,7 +1,27 @@
-import { h, defineComponent, ref, computed, watch, onBeforeUnmount } from 'vue';
-import { icon20ViewBox, chevronDownSolidIcon20PathD, closeSolidIcon20PathD, getAllTreeSelectKeys, getTreeSelectDisplayLabel, filterTreeSelectNodes, flattenTreeSelectNodes, classNames, treeSelectBaseClasses, coerceClassValue, getPickerComboboxAria, getTreeSelectTriggerClasses, treeSelectDropdownClasses, getPickerListboxAria, treeSelectSearchClasses, getTreeSelectNodeClasses, getPickerOptionAria, chevronRightSolidIcon20PathD, treeSelectEmptyClasses, getPickerTriggerKeyAction } from '@expcat/tigercat-core';
-
 // src/components/TreeSelect.ts
+import { defineComponent, h, ref, computed, watch, onBeforeUnmount } from "vue";
+import {
+  treeSelectBaseClasses,
+  treeSelectDropdownClasses,
+  treeSelectSearchClasses,
+  treeSelectEmptyClasses,
+  getTreeSelectTriggerClasses,
+  getTreeSelectNodeClasses,
+  getTreeSelectDisplayLabel,
+  getAllTreeSelectKeys,
+  flattenTreeSelectNodes,
+  filterTreeSelectNodes,
+  getPickerComboboxAria,
+  getPickerListboxAria,
+  getPickerOptionAria,
+  getPickerTriggerKeyAction,
+  coerceClassValue,
+  classNames,
+  icon20ViewBox,
+  chevronDownSolidIcon20PathD,
+  chevronRightSolidIcon20PathD,
+  closeSolidIcon20PathD
+} from "@expcat/tigercat-core";
 var treeSelectInstanceId = 0;
 var ChevronDownIcon = h(
   "svg",
@@ -310,4 +330,7 @@ var TreeSelect = defineComponent({
 });
 var TreeSelect_default = TreeSelect;
 
-export { TreeSelect, TreeSelect_default };
+export {
+  TreeSelect,
+  TreeSelect_default
+};

package/dist/chunk-LUBUJUSH.js

@@ -0,0 +1,45 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/components/Divider.ts
+var _vue = require('vue');
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var Divider = _vue.defineComponent.call(void 0, {
+  name: "TigerDivider",
+  inheritAttrs: false,
+  props: {
+    orientation: {
+      type: String,
+      default: "horizontal"
+    },
+    lineStyle: {
+      type: String,
+      default: "solid"
+    },
+    spacing: {
+      type: String,
+      default: "md"
+    },
+    color: String,
+    thickness: String
+  },
+  setup(props, { attrs }) {
+    const classes = _vue.computed.call(void 0, 
+      () => _tigercatcore.getDividerClasses.call(void 0, props.orientation, props.lineStyle, props.spacing)
+    );
+    const style = _vue.computed.call(void 0, () => _tigercatcore.getDividerStyle.call(void 0, props.orientation, props.color, props.thickness));
+    return () => _vue.h.call(void 0, "div", {
+      ...attrs,
+      class: [classes.value, attrs.class],
+      style: [style.value, attrs.style],
+      role: "separator",
+      "aria-orientation": props.orientation
+    });
+  }
+});
+var Divider_default = Divider;
+
+
+
+
+exports.Divider = Divider; exports.Divider_default = Divider_default;

package/dist/chunk-LWDA7ABQ.js

@@ -1,20 +1,26 @@
-'use strict';
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var chunkJDCVS4SJ_js = require('./chunk-JDCVS4SJ.js');
-var vue = require('vue');
-var tigercatCore = require('@expcat/tigercat-core');
 
+
+var _chunkJDCVS4SJjs = require('./chunk-JDCVS4SJ.js');
+
+// src/utils/use-floating-popup.ts
+var _vue = require('vue');
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
 function useFloatingPopup(options) {
   const { props, emit, multiTrigger = true } = options;
-  const internalVisible = vue.ref(props.open ?? props.defaultOpen ?? false);
-  const isControlled = vue.computed(() => props.open !== void 0);
-  vue.watch(
+  const internalVisible = _vue.ref.call(void 0, _nullishCoalesce(_nullishCoalesce(props.open, () => ( props.defaultOpen)), () => ( false)));
+  const isControlled = _vue.computed.call(void 0, () => props.open !== void 0);
+  _vue.watch.call(void 0, 
     () => props.open,
     (next) => {
       if (next !== void 0) internalVisible.value = next;
     }
   );
-  const currentVisible = vue.computed(
+  const currentVisible = _vue.computed.call(void 0, 
     () => isControlled.value ? Boolean(props.open) : internalVisible.value
   );
   const setVisible = (next) => {
@@ -23,34 +29,34 @@ function useFloatingPopup(options) {
     emit("update:open", next);
     emit("open-change", next);
   };
-  const containerRef = vue.ref(null);
-  const triggerRef = vue.ref(null);
-  const floatingRef = vue.ref(null);
+  const containerRef = _vue.ref.call(void 0, null);
+  const triggerRef = _vue.ref.call(void 0, null);
+  const floatingRef = _vue.ref.call(void 0, null);
   const {
     x,
     y,
     placement: actualPlacement
-  } = chunkJDCVS4SJ_js.useVueFloating({
+  } = _chunkJDCVS4SJjs.useVueFloating.call(void 0, {
     referenceRef: triggerRef,
     floatingRef,
     enabled: currentVisible,
-    placement: props.placement ?? "top",
-    offset: props.offset ?? 8
+    placement: _nullishCoalesce(props.placement, () => ( "top")),
+    offset: _nullishCoalesce(props.offset, () => ( 8))
   });
   let outsideClickCleanup;
   let escapeKeyCleanup;
-  const effectiveTrigger = vue.computed(
-    () => multiTrigger ? props.trigger ?? "click" : "click"
+  const effectiveTrigger = _vue.computed.call(void 0, 
+    () => multiTrigger ? _nullishCoalesce(props.trigger, () => ( "click")) : "click"
   );
-  vue.watch(
+  _vue.watch.call(void 0, 
     [currentVisible, effectiveTrigger],
     ([visible, trigger]) => {
-      outsideClickCleanup?.();
-      escapeKeyCleanup?.();
+      _optionalChain([outsideClickCleanup, 'optionalCall', _ => _()]);
+      _optionalChain([escapeKeyCleanup, 'optionalCall', _2 => _2()]);
       outsideClickCleanup = void 0;
       escapeKeyCleanup = void 0;
       if (visible && trigger === "click") {
-        outsideClickCleanup = chunkJDCVS4SJ_js.useVueClickOutside({
+        outsideClickCleanup = _chunkJDCVS4SJjs.useVueClickOutside.call(void 0, {
           enabled: currentVisible,
           refs: [containerRef, floatingRef],
           onOutsideClick: () => setVisible(false),
@@ -58,7 +64,7 @@ function useFloatingPopup(options) {
         });
       }
       if (visible && trigger !== "manual") {
-        escapeKeyCleanup = chunkJDCVS4SJ_js.useVueEscapeKey({
+        escapeKeyCleanup = _chunkJDCVS4SJjs.useVueEscapeKey.call(void 0, {
           enabled: currentVisible,
           onEscape: () => setVisible(false)
         });
@@ -66,15 +72,15 @@ function useFloatingPopup(options) {
     },
     { immediate: true }
   );
-  vue.onBeforeUnmount(() => {
-    outsideClickCleanup?.();
-    escapeKeyCleanup?.();
+  _vue.onBeforeUnmount.call(void 0, () => {
+    _optionalChain([outsideClickCleanup, 'optionalCall', _3 => _3()]);
+    _optionalChain([escapeKeyCleanup, 'optionalCall', _4 => _4()]);
   });
-  const floatingStyles = vue.computed(() => ({
+  const floatingStyles = _vue.computed.call(void 0, () => ({
     position: "absolute",
     left: `${x.value}px`,
     top: `${y.value}px`,
-    transformOrigin: tigercatCore.getTransformOrigin(actualPlacement.value),
+    transformOrigin: _tigercatcore.getTransformOrigin.call(void 0, actualPlacement.value),
     zIndex: 1e3
   }));
   const handleToggle = () => {
@@ -86,11 +92,11 @@ function useFloatingPopup(options) {
   const handleHide = () => {
     if (!props.disabled) setVisible(false);
   };
-  const triggerHandlers = vue.computed(() => {
+  const triggerHandlers = _vue.computed.call(void 0, () => {
     if (!multiTrigger) {
       return { onClick: handleToggle };
     }
-    return tigercatCore.buildTriggerHandlerMap(
+    return _tigercatcore.buildTriggerHandlerMap.call(void 0, 
       effectiveTrigger.value,
       { toggle: handleToggle, show: handleShow, hide: handleHide },
       "vue"
@@ -110,4 +116,6 @@ function useFloatingPopup(options) {
   };
 }
 
+
+
 exports.useFloatingPopup = useFloatingPopup;