@apple-pie/slice 0.0.6 → 0.0.8

package/dist/esm/chunks/sharedTypes-tn9-uJvb.mjs

@@ -0,0 +1,8 @@
+var ToolTipType;
+
+!function(ToolTipType) {
+    ToolTipType.menu = "menu", ToolTipType.button = "button", ToolTipType.general = "general", 
+    ToolTipType.other = "other";
+}(ToolTipType || (ToolTipType = {}));
+
+export { ToolTipType as T };

package/dist/esm/chunks/style-inject.es-D0BjEaN8.mjs

@@ -0,0 +1,11 @@
+function styleInject(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));
+    }
+}
+
+export { styleInject as s };

package/dist/esm/chunks/tipStore-CL5a95Bl.mjs

@@ -0,0 +1,15 @@
+import { create } from "zustand";
+
+const useTipStore = create(set => ({
+    tip: null,
+    actions: {
+        push: tip => set({
+            tip: tip
+        }),
+        clear: () => set({
+            tip: null
+        })
+    }
+})), useTip = () => useTipStore(state => state.tip), useTipActions = () => useTipStore(state => state.actions), tipActions = useTipStore.getState().actions, getTip = () => useTipStore.getState().tip;
+
+export { useTipActions as a, useTipStore as b, getTip as g, tipActions as t, useTip as u };

package/dist/esm/chunks/toastStore-D2PEIqCo.mjs

@@ -0,0 +1,15 @@
+import { create } from "zustand";
+
+const useToastStore = create(set => ({
+    toast: null,
+    actions: {
+        push: toast => set({
+            toast: toast
+        }),
+        clear: () => set({
+            toast: null
+        })
+    }
+})), useToast = () => useToastStore(state => state.toast), useToastActions = () => useToastStore(state => state.actions), toastActions = useToastStore.getState().actions, getToast = () => useToastStore.getState().toast;
+
+export { useToastActions as a, useToastStore as b, getToast as g, toastActions as t, useToast as u };

package/dist/esm/chunks/tslib.es6-c-7TIv71.mjs

@@ -0,0 +1,53 @@
+/******************************************************************************
+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 __rest(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;
+}
+
+function __awaiter(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());
+    });
+}
+
+"function" == typeof SuppressedError && SuppressedError;
+
+export { __rest as _, __awaiter as a };

package/dist/esm/chunks/uploads-worker-Dv-4zGnC.mjs

@@ -0,0 +1,224 @@
+import { a as __awaiter } from "./tslib.es6-c-7TIv71.mjs";
+
+var FileUploadStatus, UploadError, WorkerStatus;
+
+!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 = {})), function(WorkerStatus) {
+    WorkerStatus.Idle = "idle", WorkerStatus.Busy = "busy";
+}(WorkerStatus || (WorkerStatus = {}));
+
+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 = 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 = WorkerStatus.Idle, 
+        void this.notifyStatus();
+        for (this.workerStatus = 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 __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 = WorkerStatus.Idle, 
+                this.notifyStatus()) : this.process();
+            }
+        });
+    }
+    /**
+     * perform the actual upload
+     */    uploadFile(upload) {
+        return __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 : WorkerStatus.Idle;
+    }
+    postError(message) {
+        this.target.postMessage({
+            type: "error",
+            message: message
+        });
+    }
+}
+
+function registerUploadsWorker(target = globalThis) {
+    return new UploadsWorkerRuntime(target);
+}
+
+export { WorkerStatus as W, registerUploadsWorker as r };

package/dist/esm/chunks/uploadsStore-D69fEXMY.mjs

@@ -0,0 +1,72 @@
+import { create } from "zustand";
+
+import { W as WorkerStatus } from "./uploads-worker-Dv-4zGnC.mjs";
+
+let uploadsWorker = null;
+
+function createUploadsWorker(workerUrl) {
+    return new Worker(null != workerUrl ? workerUrl : new URL("../../workers/uploads/uploads.ts", import.meta.url), {
+        type: "module"
+    });
+}
+
+const useUploadsStore = create((set, get) => ({
+    uploads: [],
+    workerStatus: 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: 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 useUploads = () => useUploadsStore(state => state.uploads), useUploadsWorkerStatus = () => useUploadsStore(state => state.workerStatus), useUploadsInitialized = () => useUploadsStore(state => state.initialized), useUploadsError = () => useUploadsStore(state => state.error), useUploadsActions = () => useUploadsStore(state => state.actions), uploadsActions = useUploadsStore.getState().actions, getUploads = () => useUploadsStore.getState().uploads, getUploadsWorkerStatus = () => useUploadsStore.getState().workerStatus, uploadsInitialized = () => useUploadsStore.getState().initialized, getUploadsError = () => useUploadsStore.getState().error;
+
+export { getUploadsError as a, getUploadsWorkerStatus as b, createUploadsWorker as c, uploadsInitialized as d, useUploads as e, useUploadsActions as f, getUploads as g, useUploadsError as h, useUploadsInitialized as i, useUploadsStore as j, useUploadsWorkerStatus as k, uploadsActions as u };

package/dist/esm/chunks/utils-BQ1v7VE4.mjs

@@ -0,0 +1,74 @@
+import "./tslib.es6-c-7TIv71.mjs";
+
+/**
+ * Clean up string with html
+ */ function cleanString(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
+ */ function debug(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}`);
+            }
+        }
+        /**
+ * Utility to accessibility - mimics click event with designated keys event
+ */)(props, updated);
+    }
+    return {
+        props: updated,
+        mount: !1,
+        unmount: !1
+    };
+}
+
+function accessibleKeyDown(e, clickFunction, keys) {
+    [ "Enter", " " ].includes(e.key) && (e.preventDefault(), clickFunction());
+}
+
+/**
+ * Get the pointer position from a DOM touch or mouse event
+ */ function pointerPosition(e) {
+    if (e.type.startsWith("touch")) {
+        return e.touches[0].clientX;
+    }
+    return e.clientX;
+}
+
+/**
+ * Filter and trim class name array
+ */ function filterClasses(classNames) {
+    return classNames.filter(item => "" !== item).join(" ").trim();
+}
+
+/**
+ * Takes a style string or number and returns a valid CSS style string
+ */ function setStyle(value, defaultVal = void 0) {
+    const useValue = null != value ? value : defaultVal;
+    return useValue ? "string" == typeof useValue ? useValue : `${useValue}px` : "unset";
+}
+
+export { accessibleKeyDown as a, cleanString as c, debug as d, filterClasses as f, pointerPosition as p, setStyle as s };

package/dist/esm/chunks/windowStore-CwW0i_le.mjs

@@ -0,0 +1,71 @@
+import { create } from "zustand";
+
+/**
+ * Form factor names
+ */ var FormFactor;
+
+!function(FormFactor) {
+    FormFactor.Mobile = "mobile", FormFactor.Tablet = "tablet", FormFactor.Desktop = "desktop", 
+    FormFactor.DesktopL = "desktopL", FormFactor.DesktopXL = "desktopXL";
+}(FormFactor || (FormFactor = {}));
+
+/**
+ * Use bootstrap breakpoints
+ */
+const bootstrapBreakPoints = {
+    [FormFactor.Mobile]: 576,
+    [FormFactor.Tablet]: 768,
+    [FormFactor.Desktop]: 992,
+    [FormFactor.DesktopL]: 1200,
+    [FormFactor.DesktopXL]: 1400
+}, orderedBps = Object.entries(bootstrapBreakPoints).sort((a, b) => -b[1] - a[1]), getFormFactor = width => {
+    if (!width || width <= 0) return FormFactor.Mobile;
+    for (const [formFactor, breakpoint] of orderedBps) if (width >= breakpoint) return formFactor;
+    return FormFactor.Mobile;
+}, initialSize = processWindowSize(), useWindowStore = 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"
+    };
+}
+
+export { FormFactor as F, useWindowStore as u };

package/dist/esm/hooks/useDoubleClick.mjs

@@ -0,0 +1,14 @@
+import { useRef } from "react";
+
+function useDoubleClick(onClick, onDblClick, delay = 200) {
+    const timer = useRef(null);
+    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);
+    } ];
+}
+
+export { useDoubleClick };

package/dist/esm/hooks/useKeyboardShortcuts.mjs

@@ -0,0 +1,27 @@
+import { useCallback, useEffect } from "react";
+
+function useKeyboardShortcuts(shortcuts, shortCutHandler, isAppleDevice) {
+    const isEditable = useCallback(e => {
+        const target = e.target;
+        if (target) {
+            const tag = target.tagName;
+            return target.isContentEditable || "INPUT" === tag || "TEXTAREA" === tag || "SELECT" === tag;
+        }
+        return !1;
+    }, []), handleKeyPress = 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 ]);
+    useEffect(() => {
+        if (0 !== shortcuts.length) return globalThis.addEventListener("keydown", handleKeyPress, !1), 
+        () => {
+            globalThis.removeEventListener("keydown", handleKeyPress, !1);
+        };
+    }, [ shortcuts, handleKeyPress ]);
+}
+
+export { useKeyboardShortcuts };

package/dist/esm/hooks/useLastUpdated.mjs

@@ -0,0 +1,31 @@
+import { useState, useEffect } from "react";
+
+function getTimeDifference(date, labelPrefix) {
+    const compareDate = date instanceof Date ? date : new Date(date);
+    if (Number.isNaN(compareDate.getTime())) return `${labelPrefix}Invalid date`;
+    const secondsDiff = Math.max(0, Math.floor((Date.now() - compareDate.getTime()) / 1e3)), minutes = Math.floor(secondsDiff / 60), hours = Math.floor(minutes / 60), days = Math.floor(hours / 24);
+    return minutes < 1 ? `${labelPrefix}Just now` : 1 === minutes ? `${labelPrefix}1 min. ago` : minutes < 60 ? `${labelPrefix}${minutes} mins. ago` : 1 === hours ? `${labelPrefix}1 hour ago` : hours < 24 ? `${labelPrefix}${hours} hours ago` : 1 === days ? `${labelPrefix}1 day ago` : days < 15 ? `${labelPrefix}${days} days ago` : compareDate.toLocaleDateString("en-US", {
+        day: "2-digit",
+        month: "short",
+        year: "numeric"
+    });
+}
+
+function useLastUpdated(timestamp, prefix = "", interval = 1) {
+    const [lastUpdated, setLastUpdated] = useState(timestamp ? getTimeDifference(timestamp, prefix) : "");
+    return useEffect(() => {
+        if (!timestamp) return void setLastUpdated("");
+        setLastUpdated(getTimeDifference(timestamp, prefix));
+        const refreshMinutes = Math.max(interval, 1), intervalTimer = setInterval(() => {
+            setLastUpdated(getTimeDifference(timestamp, prefix));
+        }, 60 * refreshMinutes * 1e3);
+        return () => {
+            clearInterval(intervalTimer);
+        };
+    }, [ interval, prefix, timestamp ]), {
+        lastUpdated: lastUpdated,
+        timer: interval
+    };
+}
+
+export { useLastUpdated };

package/dist/esm/hooks/useLocalStore.mjs

@@ -0,0 +1,36 @@
+import { useState, useEffect } from "react";
+
+function canUseLocalStorage() {
+    return "undefined" != typeof globalThis && "localStorage" in globalThis && void 0 !== globalThis.localStorage && null !== globalThis.localStorage;
+}
+
+function readLocalStorageValue(key, fallback) {
+    if (!canUseLocalStorage()) return fallback;
+    try {
+        const raw = globalThis.localStorage.getItem(key);
+        return null === raw ? (globalThis.localStorage.setItem(key, JSON.stringify(fallback)), 
+        fallback) : JSON.parse(raw);
+    } catch (error) {
+        return console.error(`Error parsing local storage item for key ${key}:`, {
+            error: error
+        }), fallback;
+    }
+}
+
+function useLocalStore(key, value) {
+    const [item, setItem] = useState(() => readLocalStorageValue(key, value));
+    return useEffect(() => {
+        setItem(readLocalStorageValue(key, value));
+    }, [ key, value ]), [ item, function(data) {
+        if (canUseLocalStorage()) try {
+            globalThis.localStorage.setItem(key, JSON.stringify(data));
+        } catch (error) {
+            console.error(`Error setting local storage item for key ${key}:`, {
+                error: error
+            });
+        }
+        setItem(data);
+    } ];
+}
+
+export { useLocalStore };