@apple-pie/slice 0.0.5 → 0.0.7

package/dist/cjs/chunks/sharedTypes-gCECyn2N.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var ToolTipType;
+
+exports.ToolTipType = void 0, (ToolTipType = exports.ToolTipType || (exports.ToolTipType = {})).menu = "menu", 
+ToolTipType.button = "button", ToolTipType.general = "general", ToolTipType.other = "other";

package/dist/cjs/chunks/style-inject.es-CMuL-BfJ.js

@@ -0,0 +1,11 @@
+"use strict";
+
+exports.styleInject = function(css, ref) {
+    void 0 === ref && (ref = {});
+    var insertAt = ref.insertAt;
+    if (css && "undefined" != typeof document) {
+        var head = document.head || document.getElementsByTagName("head")[0], style = document.createElement("style");
+        style.type = "text/css", "top" === insertAt && head.firstChild ? head.insertBefore(style, head.firstChild) : head.appendChild(style), 
+        style.styleSheet ? style.styleSheet.cssText = css : style.appendChild(document.createTextNode(css));
+    }
+};

package/dist/cjs/chunks/tipStore-Ck4NLvml.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const useTipStore = require("zustand").create(set => ({
+    tip: null,
+    actions: {
+        push: tip => set({
+            tip: tip
+        }),
+        clear: () => set({
+            tip: null
+        })
+    }
+})), tipActions = useTipStore.getState().actions;
+
+exports.getTip = () => useTipStore.getState().tip, exports.tipActions = tipActions, 
+exports.useTip = () => useTipStore(state => state.tip), exports.useTipActions = () => useTipStore(state => state.actions), 
+exports.useTipStore = useTipStore;

package/dist/cjs/chunks/toastStore-CSStgB9d.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const useToastStore = require("zustand").create(set => ({
+    toast: null,
+    actions: {
+        push: toast => set({
+            toast: toast
+        }),
+        clear: () => set({
+            toast: null
+        })
+    }
+})), toastActions = useToastStore.getState().actions;
+
+exports.getToast = () => useToastStore.getState().toast, exports.toastActions = toastActions, 
+exports.useToast = () => useToastStore(state => state.toast), exports.useToastActions = () => useToastStore(state => state.actions), 
+exports.useToastStore = useToastStore;

package/dist/cjs/chunks/tslib.es6-C8dZW5nY.js

@@ -0,0 +1,49 @@
+"use strict";
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */ "function" == typeof SuppressedError && SuppressedError, 
+exports.__awaiter = function(thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+            try {
+                step(generator.next(value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function rejected(value) {
+            try {
+                step(generator.throw(value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function step(result) {
+            var value;
+            result.done ? resolve(result.value) : (value = result.value, value instanceof P ? value : new P(function(resolve) {
+                resolve(value);
+            })).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}, exports.__rest = function(s, e) {
+    var t = {};
+    for (var p in s) Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0 && (t[p] = s[p]);
+    if (null != s && "function" == typeof Object.getOwnPropertySymbols) {
+        var i = 0;
+        for (p = Object.getOwnPropertySymbols(s); i < p.length; i++) e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]) && (t[p[i]] = s[p[i]]);
+    }
+    return t;
+};

package/dist/cjs/chunks/uploads-worker-mD8pcsGP.js

@@ -0,0 +1,221 @@
+"use strict";
+
+var FileUploadStatus, UploadError, WorkerStatus, tslib_es6 = require("./tslib.es6-C8dZW5nY.js");
+
+!function(FileUploadStatus) {
+    FileUploadStatus.queued = "pending", FileUploadStatus.uploading = "uploading", FileUploadStatus.completed = "completed", 
+    FileUploadStatus.failed = "failed";
+}(FileUploadStatus || (FileUploadStatus = {})), function(UploadError) {
+    UploadError.SizeExceedsLimit = "size exceed limit", UploadError.TypeNotAllowed = "file type not allowed", 
+    UploadError.UploadFailed = "upload failed", UploadError.UploadURLNotFound = "invalid upload url", 
+    UploadError.AccessForbidden = "upload access forbidden", UploadError.NotAuthorized = "upload not authorized on server", 
+    UploadError.TooLarge = "payload too large for server", UploadError.MediaNotSupported = "server does not supported file type", 
+    UploadError.InternalError = "Internal server error", UploadError.Other = "Other server error";
+}(UploadError || (UploadError = {})), exports.WorkerStatus = void 0, (WorkerStatus = exports.WorkerStatus || (exports.WorkerStatus = {})).Idle = "idle", 
+WorkerStatus.Busy = "busy";
+
+class UploadWorkerClient {
+    constructor(target, getWorkerStatus) {
+        this.target = target, this.getWorkerStatus = getWorkerStatus;
+    }
+    updateStatus(status) {
+        this.target.postMessage({
+            type: "status",
+            uploads: status,
+            workerStatus: this.getWorkerStatus()
+        });
+    }
+}
+
+class UploadsWorker {
+    constructor(options, worker) {
+        this.queue = new Map, this.active = new Map, this.completed = new Map, this.failed = new Map, 
+        this.workerStatus = exports.WorkerStatus.Idle;
+        const {uploadURL: uploadURL, maxQueueSize: maxQueueSize = 5, accepted: accepted = [], maxConcurrentUploads: maxConcurrentUploads = 5, maxFileSize: maxFileSize = 5242880} = options;
+        this.uploadURL = uploadURL, this.maxQueueSize = maxQueueSize, this.maxConcurrentUploads = maxConcurrentUploads, 
+        this.accepted = accepted, this.maxFileSize = maxFileSize, this.worker = null != worker ? worker : new UploadWorkerClient(globalThis, () => this.workerStatus);
+    }
+    /**
+     * Add new files to the upload queue
+     */    addFiles(file) {
+        const uploads = Array.isArray(file) ? file : [ file ];
+        for (const item of uploads) {
+            if (this.queue.size + this.active.size >= this.maxQueueSize) break;
+            const uploadItem = item instanceof File ? {
+                file: item
+            } : item, uploadInfo = {
+                id: crypto.randomUUID(),
+                file: uploadItem.file,
+                uploadURL: uploadItem.uploadURL,
+                status: FileUploadStatus.queued
+            };
+            this.queue.set(uploadInfo.id, uploadInfo), this.notifyStatus();
+        }
+        this.process();
+    }
+    /**
+     * Stop activity and flush all maps / data
+     */    clearUploads() {
+        this.queue.clear(), this.active.clear(), this.completed.clear(), this.failed.clear(), 
+        this.notifyStatus();
+    }
+    /**
+     * Start the processing files in the upload queue
+     */    process() {
+        if (0 === this.queue.size && 0 === this.active.size) return this.workerStatus = exports.WorkerStatus.Idle, 
+        void this.notifyStatus();
+        for (this.workerStatus = exports.WorkerStatus.Busy, this.notifyStatus(); this.active.size < this.maxConcurrentUploads && this.queue.size > 0; ) {
+            const nextUpload = this.queue.values().next().value;
+            if (!nextUpload) break;
+            this.startUpload(nextUpload);
+        }
+    }
+    get status() {
+        return this.workerStatus;
+    }
+    startUpload(upload) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function*() {
+            try {
+                if (upload.file.size > this.maxFileSize) throw new Error(UploadError.SizeExceedsLimit);
+                const ext = upload.file.name.split(".").pop(), mime = upload.file.type, filter = this.accepted.length > 0, accepted = this.accepted.includes(null != ext ? ext : "") || this.accepted.includes(null != mime ? mime : "");
+                if (filter && !accepted) throw new Error(UploadError.TypeNotAllowed);
+                upload.status = FileUploadStatus.uploading, upload.progress = 0, this.queue.delete(upload.id), 
+                this.updateUploadStatus(upload), this.notifyStatus();
+                if (!(yield this.uploadFile(upload))) throw new Error(UploadError.UploadFailed);
+                upload.status = FileUploadStatus.completed, upload.progress = 100, this.updateUploadStatus(upload), 
+                this.completed.set(upload.id, upload), this.notifyStatus();
+            } catch (error) {
+                const message = error instanceof Error ? error.message : "Unknown error";
+                switch (message) {
+                  case UploadError.SizeExceedsLimit:
+                  case UploadError.TypeNotAllowed:
+                  case UploadError.UploadFailed:
+                  case UploadError.InternalError:
+                  case UploadError.UploadURLNotFound:
+                  case UploadError.TooLarge:
+                  case UploadError.AccessForbidden:
+                  case UploadError.NotAuthorized:
+                  case UploadError.MediaNotSupported:
+                  case UploadError.Other:
+                    upload.error = message;
+                    break;
+
+                  default:
+                    console.warn(error), upload.error = UploadError.Other;
+                }
+                upload.status = FileUploadStatus.failed, this.updateUploadStatus(upload), this.failed.set(upload.id, upload), 
+                this.notifyStatus();
+            } finally {
+                this.queue.delete(upload.id), this.active.delete(upload.id), 0 === this.queue.size && 0 === this.active.size ? (this.workerStatus = exports.WorkerStatus.Idle, 
+                this.notifyStatus()) : this.process();
+            }
+        });
+    }
+    /**
+     * perform the actual upload
+     */    uploadFile(upload) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function*() {
+            const formData = new FormData;
+            return formData.append("file", upload.file), new Promise((resolve, reject) => {
+                var _a;
+                const request = new XMLHttpRequest;
+                request.upload.addEventListener("progress", event => {
+                    event.lengthComputable && 0 !== event.total && (upload.progress = Math.round(event.loaded / event.total * 100), 
+                    this.updateUploadStatus(upload));
+                }), request.addEventListener("load", () => {
+                    let error;
+                    if (request.status > 300 || request.status < 200) {
+                        switch (request.status) {
+                          case 400:
+                            error = UploadError.UploadFailed;
+                            break;
+
+                          case 401:
+                            error = UploadError.NotAuthorized;
+                            break;
+
+                          case 403:
+                            error = UploadError.AccessForbidden;
+                            break;
+
+                          case 404:
+                            error = UploadError.UploadURLNotFound;
+                            break;
+
+                          case 413:
+                            error = UploadError.TooLarge;
+                            break;
+
+                          case 415:
+                            error = UploadError.MediaNotSupported;
+                            break;
+
+                          case 500:
+                            error = UploadError.InternalError;
+                            break;
+
+                          default:
+                            error = UploadError.Other;
+                        }
+                        reject(new Error(error));
+                    }
+                    resolve(!0);
+                }), request.addEventListener("error", e => {
+                    reject(new Error(UploadError.UploadFailed));
+                }), request.addEventListener("abort", () => {
+                    reject(new Error(UploadError.UploadFailed));
+                }), request.open("POST", null !== (_a = upload.uploadURL) && void 0 !== _a ? _a : this.uploadURL), 
+                request.send(formData);
+            });
+        });
+    }
+    /**
+     * Update the active upload with new data
+     */    updateUploadStatus(upload, updates = {}) {
+        const updated = Object.assign(Object.assign({}, upload), updates);
+        this.active.set(upload.id, updated), this.notifyStatus();
+    }
+    /**
+     * Create array with the current state of all uploads
+     */    currentStatus() {
+        return [ ...this.queue.values(), ...this.active.values(), ...this.completed.values(), ...this.failed.values() ];
+    }
+    /**
+     * Push status updates to the web worker
+     */    notifyStatus() {
+        this.worker.updateStatus(this.currentStatus());
+    }
+}
+
+class UploadsWorkerRuntime {
+    constructor(target) {
+        this.target = target, this.uploads = null, this.target.onmessage = event => {
+            this.handleMessage(event.data);
+        };
+    }
+    handleMessage(message) {
+        switch (message.type) {
+          case "initialize":
+            return void (this.uploads = new UploadsWorker(message.options, new UploadWorkerClient(this.target, () => this.getWorkerStatus())));
+
+          case "add-files":
+            return this.uploads ? void this.uploads.addFiles(message.files) : void this.postError("Uploads worker has not been initialized.");
+
+          case "clear-uploads":
+            return this.uploads ? void this.uploads.clearUploads() : void this.postError("Uploads worker has not been initialized.");
+        }
+    }
+    getWorkerStatus() {
+        return this.uploads ? this.uploads.status : exports.WorkerStatus.Idle;
+    }
+    postError(message) {
+        this.target.postMessage({
+            type: "error",
+            message: message
+        });
+    }
+}
+
+exports.registerUploadsWorker = function(target = globalThis) {
+    return new UploadsWorkerRuntime(target);
+};

package/dist/cjs/chunks/uploadsStore-CxWIctvI.js

@@ -0,0 +1,75 @@
+"use strict";
+
+var zustand = require("zustand"), uploadsWorker$1 = require("./uploads-worker-mD8pcsGP.js"), _documentCurrentScript = "undefined" != typeof document ? document.currentScript : null;
+
+let uploadsWorker = null;
+
+const useUploadsStore = zustand.create((set, get) => ({
+    uploads: [],
+    workerStatus: uploadsWorker$1.WorkerStatus.Idle,
+    initialized: !1,
+    error: null,
+    actions: {
+        initialize: (options, worker) => (uploadsWorker || (uploadsWorker = worker, uploadsWorker.onmessage = handleWorkerMessage), 
+        uploadsWorker.postMessage({
+            type: "initialize",
+            options: options
+        }), set({
+            initialized: !0,
+            error: null
+        }), uploadsWorker),
+        push: files => {
+            if (!uploadsWorker || !get().initialized) return;
+            const uploads = (Array.isArray(files) ? files : [ files ]).map(item => item instanceof File ? {
+                file: item
+            } : item);
+            uploadsWorker.postMessage({
+                type: "add-files",
+                files: uploads
+            });
+        },
+        reset: () => {
+            uploadsWorker && uploadsWorker.postMessage({
+                type: "clear-uploads"
+            }), set({
+                uploads: [],
+                workerStatus: uploadsWorker$1.WorkerStatus.Idle,
+                error: null
+            });
+        }
+    }
+}));
+
+function handleWorkerMessage(event) {
+    const message = event.data;
+    switch (message.type) {
+      case "status":
+        return void function(message) {
+            useUploadsStore.setState({
+                uploads: message.uploads,
+                workerStatus: message.workerStatus,
+                error: null
+            });
+        }(message);
+
+      case "error":
+        return void function(message) {
+            useUploadsStore.setState({
+                error: message.message
+            });
+        }(message);
+    }
+}
+
+const uploadsActions = useUploadsStore.getState().actions;
+
+exports.createUploadsWorker = function(workerUrl) {
+    return new Worker(null != workerUrl ? workerUrl : new URL("../../workers/uploads/uploads.ts", "undefined" == typeof document ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && "SCRIPT" === _documentCurrentScript.tagName.toUpperCase() && _documentCurrentScript.src || new URL("chunks/uploadsStore-CxWIctvI.js", document.baseURI).href), {
+        type: "module"
+    });
+}, exports.getUploads = () => useUploadsStore.getState().uploads, exports.getUploadsError = () => useUploadsStore.getState().error, 
+exports.getUploadsWorkerStatus = () => useUploadsStore.getState().workerStatus, 
+exports.uploadsActions = uploadsActions, exports.uploadsInitialized = () => useUploadsStore.getState().initialized, 
+exports.useUploads = () => useUploadsStore(state => state.uploads), exports.useUploadsActions = () => useUploadsStore(state => state.actions), 
+exports.useUploadsError = () => useUploadsStore(state => state.error), exports.useUploadsInitialized = () => useUploadsStore(state => state.initialized), 
+exports.useUploadsStore = useUploadsStore, exports.useUploadsWorkerStatus = () => useUploadsStore(state => state.workerStatus);

package/dist/cjs/chunks/utils-BsBHecUI.js

@@ -0,0 +1,70 @@
+"use strict";
+
+require("./tslib.es6-C8dZW5nY.js"), exports.accessibleKeyDown = 
+/**
+ * Utility to accessibility - mimics click event with designated keys event
+ */
+function(e, clickFunction, keys) {
+    [ "Enter", " " ].includes(e.key) && (e.preventDefault(), clickFunction());
+}
+/**
+ * Get the pointer position from a DOM touch or mouse event
+ */ , exports.cleanString = 
+/**
+ * Clean up string with html
+ */
+function(input, removeInvisible = !0, removeHtml = !0) {
+    let clean = input;
+    if (clean = clean.replaceAll(/\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, ""), 
+    removeInvisible) {
+        const invisibleRegEx = /[\r\n\t]/gi;
+        clean = clean.replaceAll(invisibleRegEx, "");
+    }
+    if (removeHtml) {
+        const htmlRegEx = /<\/?[a-z][^>]*>/gi;
+        clean = clean.replaceAll(htmlRegEx, "");
+    }
+    return clean;
+}
+/**
+ * Debug component rendering
+ * Code removed when built / deployed
+ */ , exports.debug = function(previous, updated, name = "component") {
+    if ("test" === process.env.NODE_ENV) return;
+    const props = previous.current.props, mount = previous.current.mount, unmount = previous.current.unmount;
+    if (mount) ; else if (unmount) ; else {
+        (function(props, updated) {
+            const reasons = [];
+            for (const key of Object.keys(updated)) if (updated[key] !== props[key]) try {
+                const propName = `${key}:`, prev = JSON.stringify(props[key]), valueChanged = `${prev} > ${JSON.stringify(updated[key])}`;
+                reasons.push(`${propName} ${valueChanged}`);
+            } catch (error) {
+                let message = "Unknown error";
+                error instanceof Error && (message = error.message), "string" == typeof error && (message = error), 
+                reasons.push(`${key} ${message}`);
+            }
+        })(props, updated);
+    }
+    return {
+        props: updated,
+        mount: !1,
+        unmount: !1
+    };
+}, exports.filterClasses = 
+/**
+ * Filter and trim class name array
+ */
+function(classNames) {
+    return classNames.filter(item => "" !== item).join(" ").trim();
+}
+/**
+ * Takes a style string or number and returns a valid CSS style string
+ */ , exports.pointerPosition = function(e) {
+    if (e.type.startsWith("touch")) {
+        return e.touches[0].clientX;
+    }
+    return e.clientX;
+}, exports.setStyle = function(value, defaultVal = void 0) {
+    const useValue = null != value ? value : defaultVal;
+    return useValue ? "string" == typeof useValue ? useValue : `${useValue}px` : "unset";
+};

package/dist/cjs/chunks/windowStore-RaJswiHM.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var FormFactor, zustand = require("zustand");
+
+/**
+ * Form factor names
+ */ exports.FormFactor = void 0, (FormFactor = exports.FormFactor || (exports.FormFactor = {})).Mobile = "mobile", 
+FormFactor.Tablet = "tablet", FormFactor.Desktop = "desktop", FormFactor.DesktopL = "desktopL", 
+FormFactor.DesktopXL = "desktopXL";
+
+/**
+ * Use bootstrap breakpoints
+ */
+const bootstrapBreakPoints = {
+    [exports.FormFactor.Mobile]: 576,
+    [exports.FormFactor.Tablet]: 768,
+    [exports.FormFactor.Desktop]: 992,
+    [exports.FormFactor.DesktopL]: 1200,
+    [exports.FormFactor.DesktopXL]: 1400
+}, orderedBps = Object.entries(bootstrapBreakPoints).sort((a, b) => -b[1] - a[1]), getFormFactor = width => {
+    if (!width || width <= 0) return exports.FormFactor.Mobile;
+    for (const [formFactor, breakpoint] of orderedBps) if (width >= breakpoint) return formFactor;
+    return exports.FormFactor.Mobile;
+}, initialSize = processWindowSize(), useWindowStore = zustand.create((set, get) => {
+    var _a;
+    return {
+        formFactor: initialSize.formFactor,
+        viewportWidth: initialSize.viewportWidth,
+        viewportHeight: initialSize.viewportHeight,
+        height: initialSize.height,
+        isElectron: checkElectron(),
+        isAppleDevice: navigator.platform.startsWith("Mac") || "iPhone" === navigator.platform,
+        isTouchDevice: "ontouchstart" in globalThis || navigator.maxTouchPoints > 0,
+        dpr: null !== (_a = Math.min(Math.ceil(window.devicePixelRatio), 3)) && void 0 !== _a ? _a : 1,
+        actions: {
+            initialize: () => {
+                var _a;
+                const win = null !== (_a = globalThis.top) && void 0 !== _a ? _a : globalThis;
+                return null == win || win.addEventListener("resize", handleResize), () => null == win ? void 0 : win.removeEventListener("resize", handleResize);
+            }
+        }
+    };
+});
+
+function checkElectron() {
+    return navigator.userAgent.toLowerCase().includes("electron/");
+}
+
+function handleResize() {
+    const {formFactor: formFactor, viewportWidth: viewportWidth, viewportHeight: viewportHeight, height: height} = processWindowSize();
+    useWindowStore.setState({
+        formFactor: formFactor,
+        viewportWidth: viewportWidth,
+        viewportHeight: viewportHeight,
+        height: height
+    });
+}
+
+function processWindowSize(top = !0) {
+    var _a, _b, _c;
+    const viewport = null !== (_a = globalThis.top) && void 0 !== _a ? _a : globalThis, touch = "ontouchstart" in globalThis || navigator.maxTouchPoints > 0, windowWidth = null !== (_b = null == viewport ? void 0 : viewport.innerWidth) && void 0 !== _b ? _b : -1, windowHeight = null !== (_c = null == viewport ? void 0 : viewport.innerHeight) && void 0 !== _c ? _c : -1;
+    return {
+        formFactor: getFormFactor(windowWidth),
+        viewportWidth: windowWidth,
+        viewportHeight: windowHeight,
+        height: viewport && touch ? `${windowHeight}px` : "100vh"
+    };
+}
+
+exports.useWindowStore = useWindowStore;

package/dist/cjs/hooks/useDoubleClick.js

@@ -1,26 +1,14 @@
-'use strict';
+"use strict";
 
-var React = require('react');
+var React = require("react");
 
-function useDoubleClick(onClick, onDblClick, delay = 200) {
+exports.useDoubleClick = function(onClick, onDblClick, delay = 200) {
     const timer = React.useRef(null);
-    const didClick = (payload) => {
-        if (timer.current)
-            clearTimeout(timer.current);
-        timer.current = setTimeout(() => {
-            onClick(payload);
-        }, delay);
-        return () => {
-            if (timer.current)
-                clearTimeout(timer.current);
-        };
-    };
-    const didDblClick = (payload) => {
-        if (timer.current)
-            clearTimeout(timer.current);
-        onDblClick(payload);
-    };
-    return [didClick, didDblClick];
-}
-
-exports.useDoubleClick = useDoubleClick;
+    return [ payload => (timer.current && clearTimeout(timer.current), timer.current = setTimeout(() => {
+        onClick(payload);
+    }, delay), () => {
+        timer.current && clearTimeout(timer.current);
+    }), payload => {
+        timer.current && clearTimeout(timer.current), onDblClick(payload);
+    } ];
+};

package/dist/cjs/hooks/useKeyboardShortcuts.js

@@ -1,44 +1,27 @@
-'use strict';
+"use strict";
 
-var React = require('react');
+var React = require("react");
 
-function useKeyboardShortcuts(shortcuts, shortCutHandler, isAppleDevice) {
-    // don't process shortcuts on editable elements, like inputs, editable divs, etc.
-    const isEditable = React.useCallback((e) => {
+exports.useKeyboardShortcuts = function(shortcuts, shortCutHandler, isAppleDevice) {
+    const isEditable = React.useCallback(e => {
         const target = e.target;
         if (target) {
             const tag = target.tagName;
-            return (target.isContentEditable ||
-                tag === 'INPUT' ||
-                tag === 'TEXTAREA' ||
-                tag === 'SELECT');
+            return target.isContentEditable || "INPUT" === tag || "TEXTAREA" === tag || "SELECT" === tag;
         }
-        return false;
-    }, []);
-    // get keyboard event check if it's a shortcut
-    const handleKeyPress = React.useCallback((e) => {
-        if (isEditable(e))
-            return;
-        const isMeta = (isAppleDevice && e.metaKey) || (!isAppleDevice && e.ctrlKey);
-        for (const s of shortcuts) {
-            if (s.metaPressed && !isMeta)
-                continue;
-            if (s.key.toLowerCase() === e.key.toLowerCase()) {
-                e.preventDefault();
-                shortCutHandler(s);
-                break;
-            }
+        return !1;
+    }, []), handleKeyPress = React.useCallback(e => {
+        if (isEditable(e)) return;
+        const isMeta = isAppleDevice && e.metaKey || !isAppleDevice && e.ctrlKey;
+        for (const s of shortcuts) if ((!s.metaPressed || isMeta) && s.key.toLowerCase() === e.key.toLowerCase()) {
+            e.preventDefault(), shortCutHandler(s);
+            break;
         }
-    }, [isAppleDevice, shortcuts, shortCutHandler, isEditable]);
-    // set keyboard listener
+    }, [ isAppleDevice, shortcuts, shortCutHandler, isEditable ]);
     React.useEffect(() => {
-        if (shortcuts.length === 0)
-            return;
-        globalThis.addEventListener('keydown', handleKeyPress, false);
-        return () => {
-            globalThis.removeEventListener('keydown', handleKeyPress, false);
+        if (0 !== shortcuts.length) return globalThis.addEventListener("keydown", handleKeyPress, !1), 
+        () => {
+            globalThis.removeEventListener("keydown", handleKeyPress, !1);
         };
-    }, [shortcuts, handleKeyPress]);
-}
-
-exports.useKeyboardShortcuts = useKeyboardShortcuts;
+    }, [ shortcuts, handleKeyPress ]);
+};