@helpdice/ui 1.0.1 → 1.0.2

package/esm/tree/tree.js

@@ -0,0 +1,62 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["children", "onClick", "initialExpand", "value", "className"];
+import _JSXStyle from "../styled-jsx.es.js";
+import React, { useMemo } from 'react';
+import TreeFile from './tree-file';
+import TreeFolder from './tree-folder';
+import { TreeContext } from './tree-context';
+import { tuple } from '../utils/prop-types';
+import { sortChildren } from './tree-help';
+import useClasses from '../use-classes';
+var FileTreeValueType = tuple('directory', 'file');
+var directoryType = FileTreeValueType[0];
+var makeChildren = function makeChildren() {
+  var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  if (!value || !value.length) return null;
+  return value.sort(function (a, b) {
+    if (a.type !== b.type) return a.type !== directoryType ? 1 : -1;
+    return "".concat(a.name).charCodeAt(0) - "".concat(b.name).charCodeAt(0);
+  }).map(function (item, index) {
+    if (item.type === directoryType) return /*#__PURE__*/React.createElement(TreeFolder, {
+      name: item.name,
+      extra: item.extra,
+      key: "folder-".concat(item.name, "-").concat(index)
+    }, makeChildren(item.files));
+    return /*#__PURE__*/React.createElement(TreeFile, {
+      name: item.name,
+      extra: item.extra,
+      key: "file-".concat(item.name, "-").concat(index)
+    });
+  });
+};
+var Tree = function Tree(_ref) {
+  var children = _ref.children,
+    onClick = _ref.onClick,
+    _ref$initialExpand = _ref.initialExpand,
+    initialExpand = _ref$initialExpand === void 0 ? false : _ref$initialExpand,
+    value = _ref.value,
+    className = _ref.className,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var isImperative = Boolean(value && value.length > 0);
+  var onFileClick = function onFileClick(path) {
+    onClick && onClick(path);
+  };
+  var initialValue = useMemo(function () {
+    return {
+      onFileClick: onFileClick,
+      initialExpand: initialExpand,
+      isImperative: isImperative
+    };
+  }, [initialExpand]);
+  var customChildren = isImperative ? makeChildren(value) : sortChildren(children, TreeFolder);
+  return /*#__PURE__*/React.createElement(TreeContext.Provider, {
+    value: initialValue
+  }, /*#__PURE__*/React.createElement("div", _extends({}, props, {
+    className: "jsx-2273069862" + " " + (props && props.className != null && props.className || useClasses('tree', className) || "")
+  }), customChildren, /*#__PURE__*/React.createElement(_JSXStyle, {
+    id: "2273069862"
+  }, ".tree.jsx-2273069862{padding-left:1.625rem;}")));
+};
+Tree.displayName = 'Tree';
+export default Tree;

package/esm/ui-provider/index.d.ts

@@ -0,0 +1,3 @@
+import HuiProvider from "./ui-provider";
+export type { UiProviderProps } from "./ui-provider";
+export default HuiProvider;

package/esm/ui-provider/index.js

@@ -0,0 +1,2 @@
+import HuiProvider from './ui-provider';
+export default HuiProvider;

package/esm/ui-provider/theme-provider.d.ts

@@ -0,0 +1,8 @@
+import React, { PropsWithChildren } from 'react';
+import { HUIThemes } from "../themes/presets";
+export interface Props {
+    themeType?: string;
+    themes?: Array<HUIThemes>;
+}
+declare const ThemeProvider: React.FC<PropsWithChildren<Props>>;
+export default ThemeProvider;

package/esm/ui-provider/theme-provider.js

@@ -0,0 +1,45 @@
+"use client";
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import React, { useEffect, useMemo, useState } from 'react';
+import Themes from '../themes';
+import { ThemeContext } from '../use-theme/theme-context';
+import { AllThemesContext } from '../use-all-themes/all-themes-context';
+var ThemeProvider = function ThemeProvider(_ref) {
+  var children = _ref.children,
+    themeType = _ref.themeType,
+    _ref$themes = _ref.themes,
+    themes = _ref$themes === void 0 ? [] : _ref$themes;
+  var _useState = useState({
+      themes: Themes.getPresets()
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    allThemes = _useState2[0],
+    setAllThemes = _useState2[1];
+  var currentTheme = useMemo(function () {
+    var theme = allThemes.themes.find(function (item) {
+      return item.type === themeType;
+    });
+    if (theme) return theme;
+    return Themes.getPresetStaticTheme();
+  }, [allThemes, themeType]);
+  useEffect(function () {
+    if (!(themes !== null && themes !== void 0 && themes.length)) return;
+    setAllThemes(function (last) {
+      var safeThemes = themes.filter(function (item) {
+        return Themes.isAvailableThemeType(item.type);
+      });
+      var nextThemes = Themes.getPresets().concat(safeThemes);
+      return _extends({}, last, {
+        themes: nextThemes
+      });
+    });
+  }, [themes]);
+  return /*#__PURE__*/React.createElement(AllThemesContext.Provider, {
+    value: allThemes
+  }, /*#__PURE__*/React.createElement(ThemeContext.Provider, {
+    value: currentTheme
+  }, children));
+};
+export default ThemeProvider;

package/esm/ui-provider/ui-provider.d.ts

@@ -0,0 +1,8 @@
+import React, { PropsWithChildren } from 'react';
+import { HUIThemes } from "../themes/presets";
+export type UiProviderProps = {
+    themes?: Array<HUIThemes>;
+    themeType?: string | 'dark' | 'light';
+};
+declare const HuiProvider: React.FC<PropsWithChildren<UiProviderProps>>;
+export default HuiProvider;

package/esm/ui-provider/ui-provider.js

@@ -0,0 +1,55 @@
+"use client";
+
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import React, { useMemo, useState } from 'react';
+import { HUIContent, defaultToastLayout } from '../utils/use-hd-ui-context';
+import ThemeProvider from './theme-provider';
+import useCurrentState from '../utils/use-current-state';
+import ToastContainer from '../use-toasts/toast-container';
+var HuiProvider = function HuiProvider(_ref) {
+  var themes = _ref.themes,
+    themeType = _ref.themeType,
+    children = _ref.children;
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    lastUpdateToastId = _useState2[0],
+    setLastUpdateToastId = _useState2[1];
+  var _useCurrentState = useCurrentState([]),
+    _useCurrentState2 = _slicedToArray(_useCurrentState, 3),
+    toasts = _useCurrentState2[0],
+    setToasts = _useCurrentState2[1],
+    toastsRef = _useCurrentState2[2];
+  var _useCurrentState3 = useCurrentState(defaultToastLayout),
+    _useCurrentState4 = _slicedToArray(_useCurrentState3, 3),
+    toastLayout = _useCurrentState4[0],
+    setToastLayout = _useCurrentState4[1],
+    toastLayoutRef = _useCurrentState4[2];
+  var updateToasts = function updateToasts(fn) {
+    var nextToasts = fn(toastsRef.current);
+    setToasts(nextToasts);
+  };
+  var updateToastLayout = function updateToastLayout(fn) {
+    var nextLayout = fn(toastLayoutRef.current);
+    setToastLayout(nextLayout);
+  };
+  var updateLastToastId = function updateLastToastId(fn) {
+    setLastUpdateToastId(fn());
+  };
+  var initialValue = useMemo(function () {
+    return {
+      toasts: toasts,
+      toastLayout: toastLayout,
+      updateToasts: updateToasts,
+      lastUpdateToastId: lastUpdateToastId,
+      updateToastLayout: updateToastLayout,
+      updateLastToastId: updateLastToastId
+    };
+  }, [toasts, toastLayout, lastUpdateToastId]);
+  return /*#__PURE__*/React.createElement(HUIContent.Provider, {
+    value: initialValue
+  }, /*#__PURE__*/React.createElement(ThemeProvider, {
+    themes: themes,
+    themeType: themeType
+  }, children, /*#__PURE__*/React.createElement(ToastContainer, null)));
+};
+export default HuiProvider;

package/esm/use-all-themes/all-themes-context.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { HUIThemes } from "../themes/presets";
+export type AllThemesConfig = {
+    themes: Array<HUIThemes>;
+};
+export declare const AllThemesContext: React.Context<AllThemesConfig>;
+export declare const useAllThemes: () => AllThemesConfig;

package/esm/use-all-themes/all-themes-context.js

@@ -0,0 +1,9 @@
+import React from 'react';
+import Themes from '../themes/themes';
+var defaultAllThemesConfig = {
+  themes: Themes.getPresets()
+};
+export var AllThemesContext = /*#__PURE__*/React.createContext(defaultAllThemesConfig);
+export var useAllThemes = function useAllThemes() {
+  return React.useContext(AllThemesContext);
+};

package/esm/use-all-themes/index.d.ts

@@ -0,0 +1,3 @@
+import { useAllThemes } from "./all-themes-context";
+export type { AllThemesConfig } from "./all-themes-context";
+export default useAllThemes;

package/esm/use-all-themes/index.js

@@ -0,0 +1,2 @@
+import { useAllThemes } from './all-themes-context';
+export default useAllThemes;

package/esm/use-body-scroll/index.d.ts

@@ -0,0 +1,3 @@
+import useBodyScroll from "./use-body-scroll";
+export type { BodyScrollOptions } from "./use-body-scroll";
+export default useBodyScroll;

package/esm/use-body-scroll/index.js

@@ -0,0 +1,2 @@
+import useBodyScroll from './use-body-scroll';
+export default useBodyScroll;

package/esm/use-body-scroll/use-body-scroll.d.ts

@@ -0,0 +1,11 @@
+import { Dispatch, RefObject, SetStateAction } from 'react';
+export type ElementStackItem = {
+    overflow: string;
+    paddingRight: string;
+};
+export type BodyScrollOptions = {
+    scrollLayer?: boolean;
+    delayReset?: number;
+};
+declare const useBodyScroll: (elementRef?: RefObject<HTMLElement> | null, options?: BodyScrollOptions) => [boolean, Dispatch<SetStateAction<boolean>>];
+export default useBodyScroll;

package/esm/use-body-scroll/use-body-scroll.js

@@ -0,0 +1,63 @@
+"use client";
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useEffect, useRef, useState } from 'react';
+var defaultOptions = {
+  scrollLayer: false,
+  delayReset: 0
+};
+var elementStack = new Map();
+var getOwnerPaddingRight = function getOwnerPaddingRight(element) {
+  var owner = (element === null || element === void 0 ? void 0 : element.ownerDocument) || document;
+  var view = owner.defaultView || window;
+  return Number.parseInt(view.getComputedStyle(element).paddingRight, 10) || 0;
+};
+var getOwnerScrollbarWidth = function getOwnerScrollbarWidth(element) {
+  var doc = (element === null || element === void 0 ? void 0 : element.ownerDocument) || document;
+  return Math.abs(window.innerWidth - doc.documentElement.clientWidth);
+};
+var useBodyScroll = function useBodyScroll(elementRef, options) {
+  /* istanbul ignore next */
+  if (typeof document === 'undefined') return [false, function (t) {
+    return t;
+  }];
+  var elRef = elementRef || useRef(document.body);
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    hidden = _useState2[0],
+    setHidden = _useState2[1];
+  var safeOptions = _extends({}, defaultOptions, options || {});
+  useEffect(function () {
+    if (!elRef || !elRef.current) return;
+    var lastOverflow = elRef.current.style.overflow;
+    if (hidden) {
+      if (elementStack.has(elRef.current)) return;
+      var paddingRight = getOwnerPaddingRight(elRef.current);
+      var scrollbarWidth = getOwnerScrollbarWidth(elRef.current);
+      elementStack.set(elRef.current, {
+        overflow: lastOverflow,
+        paddingRight: elRef.current.style.paddingRight
+      });
+      elRef.current.style.overflow = 'hidden';
+      elRef.current.style.paddingRight = "".concat(paddingRight + scrollbarWidth, "px");
+      return;
+    }
+
+    // reset element overflow
+    if (!elementStack.has(elRef.current)) return;
+    var reset = function reset(el) {
+      var store = elementStack.get(el);
+      if (!store) return;
+      el.style.overflow = store.overflow;
+      el.style.paddingRight = store.paddingRight;
+      elementStack["delete"](el);
+    };
+    var timer = window.setTimeout(function () {
+      reset(elRef.current);
+      window.clearTimeout(timer);
+    }, safeOptions.delayReset);
+  }, [hidden, elRef]);
+  return [hidden, setHidden];
+};
+export default useBodyScroll;

package/esm/use-classes/index.d.ts

@@ -0,0 +1,2 @@
+import { default as useClasses } from "./use-classes";
+export default useClasses;

package/esm/use-classes/index.js

@@ -0,0 +1,2 @@
+import { default as useClasses } from './use-classes';
+export default useClasses;

package/esm/use-classes/use-classes.d.ts

@@ -0,0 +1,4 @@
+export type classNamesObject = Record<string, boolean | string | number | null | undefined>;
+export type className = string | classNamesObject | null | undefined | boolean | number;
+declare const useClasses: (...classNames: Array<className>) => string;
+export default useClasses;

package/esm/use-classes/use-classes.js

@@ -0,0 +1,32 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+var classObjectToString = function classObjectToString(className) {
+  var keys = Object.keys(className);
+  var len = keys.length;
+  var str = '';
+  for (var index = 0; index < len; index++) {
+    var key = keys[index];
+    var val = className[keys[index]];
+    if (!val) continue;
+    str = str ? "".concat(str, " ").concat(String(key)) : String(key);
+  }
+  return str;
+};
+var isObjectClassName = function isObjectClassName(value) {
+  return _typeof(value) === 'object' && !Array.isArray(value);
+};
+var useClasses = function useClasses() {
+  var len = arguments.length;
+  var classes = '';
+  if (len === 0) return classes;
+  for (var index = 0; index < len; index++) {
+    var val = index < 0 || arguments.length <= index ? undefined : arguments[index];
+    if (!val) continue;
+    if (isObjectClassName(val)) {
+      classes += " ".concat(classObjectToString(val));
+    } else {
+      classes += " ".concat(String(val).trim());
+    }
+  }
+  return classes.trim();
+};
+export default useClasses;

package/esm/use-click-away/index.d.ts

@@ -0,0 +1,2 @@
+import useClickAway from "./use-click-away";
+export default useClickAway;

package/esm/use-click-away/index.js

@@ -0,0 +1,2 @@
+import useClickAway from './use-click-away';
+export default useClickAway;

package/esm/use-click-away/use-click-away.d.ts

@@ -0,0 +1,4 @@
+import { MutableRefObject } from 'react';
+export type ClickAwayGetContainer = () => HTMLElement | null;
+declare const useClickAway: (ref: MutableRefObject<HTMLElement | null>, handler: (event: Event) => void) => void;
+export default useClickAway;

package/esm/use-click-away/use-click-away.js

@@ -0,0 +1,21 @@
+"use client";
+
+import { useEffect, useRef } from 'react';
+var useClickAway = function useClickAway(ref, handler) {
+  var handlerRef = useRef(handler);
+  useEffect(function () {
+    handlerRef.current = handler;
+  }, [handler]);
+  useEffect(function () {
+    var callback = function callback(event) {
+      var el = ref.current;
+      if (!event || !el || el.contains(event.target)) return;
+      handlerRef.current(event);
+    };
+    document.addEventListener('click', callback);
+    return function () {
+      return document.removeEventListener('click', callback);
+    };
+  }, [ref]);
+};
+export default useClickAway;

package/esm/use-clipboard/index.d.ts

@@ -0,0 +1,3 @@
+import useClipboard from "./use-clipboard";
+export type { UseClipboardOptions, UseClipboardResult } from "./use-clipboard";
+export default useClipboard;

package/esm/use-clipboard/index.js

@@ -0,0 +1,2 @@
+import useClipboard from './use-clipboard';
+export default useClipboard;

package/esm/use-clipboard/use-clipboard.d.ts

@@ -0,0 +1,8 @@
+export type UseClipboardOptions = {
+    onError: () => unknown;
+};
+export type UseClipboardResult = {
+    copy: (text: string) => void;
+};
+declare const useClipboard: (options?: UseClipboardOptions) => UseClipboardResult;
+export default useClipboard;

package/esm/use-clipboard/use-clipboard.js

@@ -0,0 +1,39 @@
+import usePortal from '../utils/use-portal';
+import useWarning from '../utils/use-warning';
+import { useCallback } from 'react';
+var defaultOptions = {
+  onError: function onError() {
+    return useWarning('Failed to copy.', 'use-clipboard');
+  }
+};
+var useClipboard = function useClipboard() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultOptions;
+  var el = usePortal('clipboard');
+  var copyText = function copyText(el, text) {
+    if (!el || !text) return;
+    var selection = window.getSelection();
+    if (!selection) return;
+    el.style.whiteSpace = 'pre';
+    el.textContent = text;
+    var range = window.document.createRange();
+    selection.removeAllRanges();
+    range.selectNode(el);
+    selection.addRange(range);
+    try {
+      window.document.execCommand('copy');
+    } catch (e) {
+      options.onError && options.onError();
+    }
+    selection.removeAllRanges();
+    if (el) {
+      el.textContent = '';
+    }
+  };
+  var copy = useCallback(function (text) {
+    copyText(el, text);
+  }, [el]);
+  return {
+    copy: copy
+  };
+};
+export default useClipboard;

package/esm/use-current-state/index.d.ts

@@ -0,0 +1,2 @@
+import useCurrentState from "./use-current-state";
+export default useCurrentState;

package/esm/use-current-state/index.js

@@ -0,0 +1,2 @@
+import useCurrentState from './use-current-state';
+export default useCurrentState;

package/esm/use-current-state/use-current-state.d.ts

@@ -0,0 +1,4 @@
+import { Dispatch, MutableRefObject, SetStateAction } from 'react';
+export type CurrentStateType<S> = [S, Dispatch<SetStateAction<S>>, MutableRefObject<S>];
+declare const useCurrentState: <S>(initialState: S | (() => S)) => CurrentStateType<S>;
+export default useCurrentState;

package/esm/use-current-state/use-current-state.js

@@ -0,0 +1,23 @@
+"use client";
+
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useEffect, useRef, useState } from 'react';
+var useCurrentState = function useCurrentState(initialState) {
+  var _useState = useState(function () {
+      return typeof initialState === 'function' ? initialState() : initialState;
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    state = _useState2[0],
+    setState = _useState2[1];
+  var ref = useRef(initialState);
+  useEffect(function () {
+    ref.current = state;
+  }, [state]);
+  var setValue = function setValue(val) {
+    var result = typeof val === 'function' ? val(ref.current) : val;
+    ref.current = result;
+    setState(result);
+  };
+  return [state, setValue, ref];
+};
+export default useCurrentState;

package/esm/use-input/index.d.ts

@@ -0,0 +1,3 @@
+import useInput from "./use-input";
+export type { BindingsChangeTarget } from "./use-input";
+export default useInput;

package/esm/use-input/index.js

@@ -0,0 +1,2 @@
+import useInput from './use-input';
+export default useInput;

package/esm/use-input/use-input.d.ts

@@ -0,0 +1,13 @@
+import React, { Dispatch, MutableRefObject, SetStateAction } from 'react';
+export type BindingsChangeTarget = React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement> | string;
+declare const useInput: (initialValue: string) => {
+    state: string;
+    setState: Dispatch<SetStateAction<string>>;
+    currentRef: MutableRefObject<string>;
+    reset: () => void;
+    bindings: {
+        value: string;
+        onChange: (event: BindingsChangeTarget) => void;
+    };
+};
+export default useInput;

package/esm/use-input/use-input.js

@@ -0,0 +1,29 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import useCurrentState from '../utils/use-current-state';
+var useInput = function useInput(initialValue) {
+  var _useCurrentState = useCurrentState(initialValue),
+    _useCurrentState2 = _slicedToArray(_useCurrentState, 3),
+    state = _useCurrentState2[0],
+    setState = _useCurrentState2[1],
+    currentRef = _useCurrentState2[2];
+  return {
+    state: state,
+    setState: setState,
+    currentRef: currentRef,
+    reset: function reset() {
+      return setState(initialValue);
+    },
+    bindings: {
+      value: state,
+      onChange: function onChange(event) {
+        if (_typeof(event) === 'object' && event.target) {
+          setState(event.target.value);
+        } else {
+          setState(event);
+        }
+      }
+    }
+  };
+};
+export default useInput;

package/esm/use-keyboard/codes.d.ts

@@ -0,0 +1,92 @@
+/**
+ * KeyBinding Codes
+ * The content of this file is based on the design of the open source project "microsoft/vscode",
+ *   Copyright (c) Microsoft Corporation. All rights reserved.
+ *
+ * We inherit the KeyMod values from "microsoft/vscode",
+ * but use the Browser's KeyboardEvent event implementation, and all values are used only as identification.
+ */
+export declare enum KeyCode {
+    Unknown = 0,
+    Backspace = 8,
+    Tab = 9,
+    Enter = 13,
+    Shift = 16,
+    Ctrl = 17,
+    Alt = 18,
+    PauseBreak = 19,
+    CapsLock = 20,
+    Escape = 27,
+    Space = 32,
+    PageUp = 33,
+    PageDown = 34,
+    End = 35,
+    Home = 36,
+    LeftArrow = 37,
+    UpArrow = 38,
+    RightArrow = 39,
+    DownArrow = 40,
+    Insert = 45,
+    Delete = 46,
+    KEY_0 = 48,
+    KEY_1 = 49,
+    KEY_2 = 50,
+    KEY_3 = 51,
+    KEY_4 = 52,
+    KEY_5 = 53,
+    KEY_6 = 54,
+    KEY_7 = 55,
+    KEY_8 = 56,
+    KEY_9 = 57,
+    KEY_A = 65,
+    KEY_B = 66,
+    KEY_C = 67,
+    KEY_D = 68,
+    KEY_E = 69,
+    KEY_F = 70,
+    KEY_G = 71,
+    KEY_H = 72,
+    KEY_I = 73,
+    KEY_J = 74,
+    KEY_K = 75,
+    KEY_L = 76,
+    KEY_M = 77,
+    KEY_N = 78,
+    KEY_O = 79,
+    KEY_P = 80,
+    KEY_Q = 81,
+    KEY_R = 82,
+    KEY_S = 83,
+    KEY_T = 84,
+    KEY_U = 85,
+    KEY_V = 86,
+    KEY_W = 87,
+    KEY_X = 88,
+    KEY_Y = 89,
+    KEY_Z = 90,
+    Meta = 91,
+    F1 = 112,
+    F2 = 113,
+    F3 = 114,
+    F4 = 115,
+    F5 = 116,
+    F6 = 117,
+    F7 = 118,
+    F8 = 119,
+    F9 = 120,
+    F10 = 121,
+    F11 = 122,
+    F12 = 123,
+    NumLock = 144,
+    ScrollLock = 145,
+    Equal = 187,
+    Minus = 189,
+    Backquote = 192,
+    Backslash = 220
+}
+export declare enum KeyMod {
+    CtrlCmd = 2048,
+    Shift = 1024,
+    Alt = 512,
+    WinCtrl = 256
+}