@soul-refiner/design-system 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/node_modules/is-hotkey/lib/index.js

@@ -0,0 +1,253 @@
+'use strict';
+
+var index = require('../../../_virtual/index.js');
+
+Object.defineProperty(index.__exports, "__esModule", {
+  value: true
+});
+
+/**
+ * Constants.
+ */
+
+var IS_MAC = typeof window != 'undefined' && /Mac|iPod|iPhone|iPad/.test(window.navigator.platform);
+
+var MODIFIERS = {
+  alt: 'altKey',
+  control: 'ctrlKey',
+  meta: 'metaKey',
+  shift: 'shiftKey'
+};
+
+var ALIASES = {
+  add: '+',
+  break: 'pause',
+  cmd: 'meta',
+  command: 'meta',
+  ctl: 'control',
+  ctrl: 'control',
+  del: 'delete',
+  down: 'arrowdown',
+  esc: 'escape',
+  ins: 'insert',
+  left: 'arrowleft',
+  mod: IS_MAC ? 'meta' : 'control',
+  opt: 'alt',
+  option: 'alt',
+  return: 'enter',
+  right: 'arrowright',
+  space: ' ',
+  spacebar: ' ',
+  up: 'arrowup',
+  win: 'meta',
+  windows: 'meta'
+};
+
+var CODES = {
+  backspace: 8,
+  tab: 9,
+  enter: 13,
+  shift: 16,
+  control: 17,
+  alt: 18,
+  pause: 19,
+  capslock: 20,
+  escape: 27,
+  ' ': 32,
+  pageup: 33,
+  pagedown: 34,
+  end: 35,
+  home: 36,
+  arrowleft: 37,
+  arrowup: 38,
+  arrowright: 39,
+  arrowdown: 40,
+  insert: 45,
+  delete: 46,
+  meta: 91,
+  numlock: 144,
+  scrolllock: 145,
+  ';': 186,
+  '=': 187,
+  ',': 188,
+  '-': 189,
+  '.': 190,
+  '/': 191,
+  '`': 192,
+  '[': 219,
+  '\\': 220,
+  ']': 221,
+  '\'': 222
+};
+
+for (var f = 1; f < 20; f++) {
+  CODES['f' + f] = 111 + f;
+}
+
+/**
+ * Is hotkey?
+ */
+
+function isHotkey(hotkey, options, event) {
+  if (options && !('byKey' in options)) {
+    event = options;
+    options = null;
+  }
+
+  if (!Array.isArray(hotkey)) {
+    hotkey = [hotkey];
+  }
+
+  var array = hotkey.map(function (string) {
+    return parseHotkey(string, options);
+  });
+  var check = function check(e) {
+    return array.some(function (object) {
+      return compareHotkey(object, e);
+    });
+  };
+  var ret = event == null ? check : check(event);
+  return ret;
+}
+
+function isCodeHotkey(hotkey, event) {
+  return isHotkey(hotkey, event);
+}
+
+function isKeyHotkey(hotkey, event) {
+  return isHotkey(hotkey, { byKey: true }, event);
+}
+
+/**
+ * Parse.
+ */
+
+function parseHotkey(hotkey, options) {
+  var byKey = options && options.byKey;
+  var ret = {};
+
+  // Special case to handle the `+` key since we use it as a separator.
+  hotkey = hotkey.replace('++', '+add');
+  var values = hotkey.split('+');
+  var length = values.length;
+
+  // Ensure that all the modifiers are set to false unless the hotkey has them.
+
+  for (var k in MODIFIERS) {
+    ret[MODIFIERS[k]] = false;
+  }
+
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = values[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var value = _step.value;
+
+      var optional = value.endsWith('?') && value.length > 1;
+
+      if (optional) {
+        value = value.slice(0, -1);
+      }
+
+      var name = toKeyName(value);
+      var modifier = MODIFIERS[name];
+
+      if (value.length > 1 && !modifier && !ALIASES[value] && !CODES[name]) {
+        throw new TypeError('Unknown modifier: "' + value + '"');
+      }
+
+      if (length === 1 || !modifier) {
+        if (byKey) {
+          ret.key = name;
+        } else {
+          ret.which = toKeyCode(value);
+        }
+      }
+
+      if (modifier) {
+        ret[modifier] = optional ? null : true;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+
+  return ret;
+}
+
+/**
+ * Compare.
+ */
+
+function compareHotkey(object, event) {
+  for (var key in object) {
+    var expected = object[key];
+    var actual = void 0;
+
+    if (expected == null) {
+      continue;
+    }
+
+    if (key === 'key' && event.key != null) {
+      actual = event.key.toLowerCase();
+    } else if (key === 'which') {
+      actual = expected === 91 && event.which === 93 ? 91 : event.which;
+    } else {
+      actual = event[key];
+    }
+
+    if (actual == null && expected === false) {
+      continue;
+    }
+
+    if (actual !== expected) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Utils.
+ */
+
+function toKeyCode(name) {
+  name = toKeyName(name);
+  var code = CODES[name] || name.toUpperCase().charCodeAt(0);
+  return code;
+}
+
+function toKeyName(name) {
+  name = name.toLowerCase();
+  name = ALIASES[name] || name;
+  return name;
+}
+
+/**
+ * Export.
+ */
+
+index.__exports.default = isHotkey;
+index.__exports.isHotkey = isHotkey;
+index.__exports.isCodeHotkey = isCodeHotkey;
+var isKeyHotkey_1 = index.__exports.isKeyHotkey = isKeyHotkey;
+index.__exports.parseHotkey = parseHotkey;
+index.__exports.compareHotkey = compareHotkey;
+index.__exports.toKeyCode = toKeyCode;
+index.__exports.toKeyName = toKeyName;
+
+exports.isKeyHotkey = isKeyHotkey_1;

package/dist/node_modules/jotai/esm/react/utils.js

@@ -0,0 +1,29 @@
+"use client";
+'use strict';
+
+require('react');
+var react = require('../react.js');
+require('../vanilla/utils.js');
+require('../vanilla.js');
+
+const hydratedMap = /* @__PURE__ */ new WeakMap();
+function useHydrateAtoms(values, options) {
+  const store = react.useStore(options);
+  const hydratedSet = getHydratedSet(store);
+  for (const [atom, value] of values) {
+    if (!hydratedSet.has(atom) || (options == null ? void 0 : options.dangerouslyForceHydrate)) {
+      hydratedSet.add(atom);
+      store.set(atom, value);
+    }
+  }
+}
+const getHydratedSet = (store) => {
+  let hydratedSet = hydratedMap.get(store);
+  if (!hydratedSet) {
+    hydratedSet = /* @__PURE__ */ new WeakSet();
+    hydratedMap.set(store, hydratedSet);
+  }
+  return hydratedSet;
+};
+
+exports.useHydrateAtoms = useHydrateAtoms;

package/dist/node_modules/jotai/esm/react.js

@@ -0,0 +1,116 @@
+"use client";
+'use strict';
+
+var React = require('react');
+var vanilla = require('./vanilla.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+const StoreContext = React.createContext(void 0);
+const useStore = (options) => {
+  const store = React.useContext(StoreContext);
+  return (options == null ? void 0 : options.store) || store || vanilla.getDefaultStore();
+};
+const Provider = ({
+  children,
+  store
+}) => {
+  const storeRef = React.useRef();
+  if (!store && !storeRef.current) {
+    storeRef.current = vanilla.createStore();
+  }
+  return React.createElement(
+    StoreContext.Provider,
+    {
+      value: store || storeRef.current
+    },
+    children
+  );
+};
+
+const isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === "function";
+const use = React__default.default.use || ((promise) => {
+  if (promise.status === "pending") {
+    throw promise;
+  } else if (promise.status === "fulfilled") {
+    return promise.value;
+  } else if (promise.status === "rejected") {
+    throw promise.reason;
+  } else {
+    promise.status = "pending";
+    promise.then(
+      (v) => {
+        promise.status = "fulfilled";
+        promise.value = v;
+      },
+      (e) => {
+        promise.status = "rejected";
+        promise.reason = e;
+      }
+    );
+    throw promise;
+  }
+});
+function useAtomValue(atom, options) {
+  const store = useStore(options);
+  const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = React.useReducer(
+    (prev) => {
+      const nextValue = store.get(atom);
+      if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {
+        return prev;
+      }
+      return [nextValue, store, atom];
+    },
+    void 0,
+    () => [store.get(atom), store, atom]
+  );
+  let value = valueFromReducer;
+  if (storeFromReducer !== store || atomFromReducer !== atom) {
+    rerender();
+    value = store.get(atom);
+  }
+  const delay = options == null ? void 0 : options.delay;
+  React.useEffect(() => {
+    const unsub = store.sub(atom, () => {
+      if (typeof delay === "number") {
+        setTimeout(rerender, delay);
+        return;
+      }
+      rerender();
+    });
+    rerender();
+    return unsub;
+  }, [store, atom, delay]);
+  React.useDebugValue(value);
+  return isPromiseLike(value) ? use(value) : value;
+}
+
+function useSetAtom(atom, options) {
+  const store = useStore(options);
+  const setAtom = React.useCallback(
+    (...args) => {
+      if ((undefined ? undefined.MODE : void 0) !== "production" && !("write" in atom)) {
+        throw new Error("not writable atom");
+      }
+      return store.set(atom, ...args);
+    },
+    [store, atom]
+  );
+  return setAtom;
+}
+
+function useAtom(atom, options) {
+  return [
+    useAtomValue(atom, options),
+    // We do wrong type assertion here, which results in throwing an error.
+    useSetAtom(atom, options)
+  ];
+}
+
+exports.Provider = Provider;
+exports.useAtom = useAtom;
+exports.useAtomValue = useAtomValue;
+exports.useSetAtom = useSetAtom;
+exports.useStore = useStore;

package/dist/node_modules/jotai/esm/vanilla/utils.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var vanilla = require('../vanilla.js');
+
+Symbol(
+  (undefined ? undefined.MODE : void 0) !== "production" ? "RESET" : ""
+);
+
+const getCached$2 = (c, m, k) => (m.has(k) ? m : m.set(k, c())).get(k);
+const cache1$4 = /* @__PURE__ */ new WeakMap();
+const memo3 = (create, dep1, dep2, dep3) => {
+  const cache2 = getCached$2(() => /* @__PURE__ */ new WeakMap(), cache1$4, dep1);
+  const cache3 = getCached$2(() => /* @__PURE__ */ new WeakMap(), cache2, dep2);
+  return getCached$2(create, cache3, dep3);
+};
+function selectAtom(anAtom, selector, equalityFn = Object.is) {
+  return memo3(
+    () => {
+      const EMPTY = Symbol();
+      const selectValue = ([value, prevSlice]) => {
+        if (prevSlice === EMPTY) {
+          return selector(value);
+        }
+        const slice = selector(value, prevSlice);
+        return equalityFn(prevSlice, slice) ? prevSlice : slice;
+      };
+      const derivedAtom = vanilla.atom((get) => {
+        const prev = get(derivedAtom);
+        const value = get(anAtom);
+        if (value instanceof Promise || prev instanceof Promise) {
+          return Promise.all([value, prev]).then(selectValue);
+        }
+        return selectValue([value, prev]);
+      });
+      derivedAtom.init = EMPTY;
+      return derivedAtom;
+    },
+    anAtom,
+    selector,
+    equalityFn
+  );
+}
+
+exports.selectAtom = selectAtom;