@eightshift/ui-components 0.0.1

package/dist/useListData-BelKu4kx.js

@@ -0,0 +1,211 @@
+import { useState, useMemo } from "react";
+function $0d86e9c8f07f9a7b$export$762f73dccccd255d(options) {
+  let { initialItems = [], initialSelectedKeys, getKey = (item) => item.id || item.key, filter, initialFilterText = "" } = options;
+  let [state, setState] = useState({
+    items: initialItems,
+    selectedKeys: initialSelectedKeys === "all" ? "all" : new Set(initialSelectedKeys || []),
+    filterText: initialFilterText
+  });
+  let filteredItems = useMemo(() => filter ? state.items.filter((item) => filter(item, state.filterText)) : state.items, [
+    state.items,
+    state.filterText,
+    filter
+  ]);
+  return {
+    ...state,
+    items: filteredItems,
+    ...$0d86e9c8f07f9a7b$export$79c0c687a5963b0a({
+      getKey
+    }, setState),
+    getItem(key) {
+      return state.items.find((item) => getKey(item) === key);
+    }
+  };
+}
+function $0d86e9c8f07f9a7b$export$79c0c687a5963b0a(opts, dispatch) {
+  let { cursor, getKey } = opts;
+  return {
+    setSelectedKeys(selectedKeys) {
+      dispatch((state) => ({
+        ...state,
+        selectedKeys
+      }));
+    },
+    setFilterText(filterText) {
+      dispatch((state) => ({
+        ...state,
+        filterText
+      }));
+    },
+    insert(index, ...values) {
+      dispatch((state) => $0d86e9c8f07f9a7b$var$insert(state, index, ...values));
+    },
+    insertBefore(key, ...values) {
+      dispatch((state) => {
+        let index = state.items.findIndex((item) => getKey(item) === key);
+        if (index === -1) {
+          if (state.items.length === 0)
+            index = 0;
+          else
+            return state;
+        }
+        return $0d86e9c8f07f9a7b$var$insert(state, index, ...values);
+      });
+    },
+    insertAfter(key, ...values) {
+      dispatch((state) => {
+        let index = state.items.findIndex((item) => getKey(item) === key);
+        if (index === -1) {
+          if (state.items.length === 0)
+            index = 0;
+          else
+            return state;
+        }
+        return $0d86e9c8f07f9a7b$var$insert(state, index + 1, ...values);
+      });
+    },
+    prepend(...values) {
+      dispatch((state) => $0d86e9c8f07f9a7b$var$insert(state, 0, ...values));
+    },
+    append(...values) {
+      dispatch((state) => $0d86e9c8f07f9a7b$var$insert(state, state.items.length, ...values));
+    },
+    remove(...keys) {
+      dispatch((state) => {
+        let keySet = new Set(keys);
+        let items = state.items.filter((item) => !keySet.has(getKey(item)));
+        let selection = "all";
+        if (state.selectedKeys !== "all") {
+          selection = new Set(state.selectedKeys);
+          for (let key of keys)
+            selection.delete(key);
+        }
+        if (cursor == null && items.length === 0)
+          selection = /* @__PURE__ */ new Set();
+        return {
+          ...state,
+          items,
+          selectedKeys: selection
+        };
+      });
+    },
+    removeSelectedItems() {
+      dispatch((state) => {
+        if (state.selectedKeys === "all")
+          return {
+            ...state,
+            items: [],
+            selectedKeys: /* @__PURE__ */ new Set()
+          };
+        let selectedKeys = state.selectedKeys;
+        let items = state.items.filter((item) => !selectedKeys.has(getKey(item)));
+        return {
+          ...state,
+          items,
+          selectedKeys: /* @__PURE__ */ new Set()
+        };
+      });
+    },
+    move(key, toIndex) {
+      dispatch((state) => {
+        let index = state.items.findIndex((item2) => getKey(item2) === key);
+        if (index === -1)
+          return state;
+        let copy = state.items.slice();
+        let [item] = copy.splice(index, 1);
+        copy.splice(toIndex, 0, item);
+        return {
+          ...state,
+          items: copy
+        };
+      });
+    },
+    moveBefore(key, keys) {
+      dispatch((state) => {
+        let toIndex = state.items.findIndex((item) => getKey(item) === key);
+        if (toIndex === -1)
+          return state;
+        let keyArray = Array.isArray(keys) ? keys : [
+          ...keys
+        ];
+        let indices = keyArray.map((key2) => state.items.findIndex((item) => getKey(item) === key2)).sort((a, b) => a - b);
+        return $0d86e9c8f07f9a7b$var$move(state, indices, toIndex);
+      });
+    },
+    moveAfter(key, keys) {
+      dispatch((state) => {
+        let toIndex = state.items.findIndex((item) => getKey(item) === key);
+        if (toIndex === -1)
+          return state;
+        let keyArray = Array.isArray(keys) ? keys : [
+          ...keys
+        ];
+        let indices = keyArray.map((key2) => state.items.findIndex((item) => getKey(item) === key2)).sort((a, b) => a - b);
+        return $0d86e9c8f07f9a7b$var$move(state, indices, toIndex + 1);
+      });
+    },
+    update(key, newValue) {
+      dispatch((state) => {
+        let index = state.items.findIndex((item) => getKey(item) === key);
+        if (index === -1)
+          return state;
+        return {
+          ...state,
+          items: [
+            ...state.items.slice(0, index),
+            newValue,
+            ...state.items.slice(index + 1)
+          ]
+        };
+      });
+    }
+  };
+}
+function $0d86e9c8f07f9a7b$var$insert(state, index, ...values) {
+  return {
+    ...state,
+    items: [
+      ...state.items.slice(0, index),
+      ...values,
+      ...state.items.slice(index)
+    ]
+  };
+}
+function $0d86e9c8f07f9a7b$var$move(state, indices, toIndex) {
+  toIndex -= indices.filter((index) => index < toIndex).length;
+  let moves = indices.map((from) => ({
+    from,
+    to: toIndex++
+  }));
+  for (let i = 0; i < moves.length; i++) {
+    let a = moves[i].from;
+    for (let j = i; j < moves.length; j++) {
+      let b = moves[j].from;
+      if (b > a)
+        moves[j].from--;
+    }
+  }
+  for (let i = 0; i < moves.length; i++) {
+    let a = moves[i];
+    for (let j = moves.length - 1; j > i; j--) {
+      let b = moves[j];
+      if (b.from < a.to)
+        a.to++;
+      else
+        b.from++;
+    }
+  }
+  let copy = state.items.slice();
+  for (let move of moves) {
+    let [item] = copy.splice(move.from, 1);
+    copy.splice(move.to, 0, item);
+  }
+  return {
+    ...state,
+    items: copy
+  };
+}
+export {
+  $0d86e9c8f07f9a7b$export$762f73dccccd255d as $,
+  $0d86e9c8f07f9a7b$export$79c0c687a5963b0a as a
+};

package/dist/useListState-Domq0blV.js

@@ -0,0 +1,137 @@
+import { $ as $7af3f5b51489e0b5$export$253fe78d46329472, a as $7613b1592d41b092$export$6cd28814d92fa9c9, b as $d496c0a20b6e58ec$export$6c8a5aaad13c9852 } from "./SelectionManager-mefd0ThJ.js";
+import { useMemo, useCallback, useRef, useEffect } from "react";
+class $a02d57049d202695$export$d085fb9e920b5ca7 {
+  *[Symbol.iterator]() {
+    yield* this.iterable;
+  }
+  get size() {
+    return this.keyMap.size;
+  }
+  getKeys() {
+    return this.keyMap.keys();
+  }
+  getKeyBefore(key) {
+    let node = this.keyMap.get(key);
+    return node ? node.prevKey : null;
+  }
+  getKeyAfter(key) {
+    let node = this.keyMap.get(key);
+    return node ? node.nextKey : null;
+  }
+  getFirstKey() {
+    return this.firstKey;
+  }
+  getLastKey() {
+    return this.lastKey;
+  }
+  getItem(key) {
+    return this.keyMap.get(key);
+  }
+  at(idx) {
+    const keys = [
+      ...this.getKeys()
+    ];
+    return this.getItem(keys[idx]);
+  }
+  getChildren(key) {
+    let node = this.keyMap.get(key);
+    return (node === null || node === void 0 ? void 0 : node.childNodes) || [];
+  }
+  constructor(nodes) {
+    this.keyMap = /* @__PURE__ */ new Map();
+    this.iterable = nodes;
+    let visit = (node) => {
+      this.keyMap.set(node.key, node);
+      if (node.childNodes && node.type === "section")
+        for (let child of node.childNodes)
+          visit(child);
+    };
+    for (let node of nodes)
+      visit(node);
+    let last;
+    let index = 0;
+    for (let [key, node] of this.keyMap) {
+      if (last) {
+        last.nextKey = key;
+        node.prevKey = last.key;
+      } else {
+        this.firstKey = key;
+        node.prevKey = void 0;
+      }
+      if (node.type === "item")
+        node.index = index++;
+      last = node;
+      last.nextKey = void 0;
+    }
+    this.lastKey = last === null || last === void 0 ? void 0 : last.key;
+  }
+}
+function $e72dd72e1c76a225$export$2f645645f7bca764(props) {
+  let { filter } = props;
+  let selectionState = $7af3f5b51489e0b5$export$253fe78d46329472(props);
+  let disabledKeys = useMemo(() => props.disabledKeys ? new Set(props.disabledKeys) : /* @__PURE__ */ new Set(), [
+    props.disabledKeys
+  ]);
+  let factory = useCallback((nodes) => filter ? new $a02d57049d202695$export$d085fb9e920b5ca7(filter(nodes)) : new $a02d57049d202695$export$d085fb9e920b5ca7(nodes), [
+    filter
+  ]);
+  let context = useMemo(() => ({
+    suppressTextValueWarning: props.suppressTextValueWarning
+  }), [
+    props.suppressTextValueWarning
+  ]);
+  let collection = $7613b1592d41b092$export$6cd28814d92fa9c9(props, factory, context);
+  let selectionManager = useMemo(() => new $d496c0a20b6e58ec$export$6c8a5aaad13c9852(collection, selectionState), [
+    collection,
+    selectionState
+  ]);
+  const cachedCollection = useRef(null);
+  useEffect(() => {
+    if (selectionState.focusedKey != null && !collection.getItem(selectionState.focusedKey)) {
+      const startItem = cachedCollection.current.getItem(selectionState.focusedKey);
+      const cachedItemNodes = [
+        ...cachedCollection.current.getKeys()
+      ].map((key) => {
+        const itemNode = cachedCollection.current.getItem(key);
+        return itemNode.type === "item" ? itemNode : null;
+      }).filter((node) => node !== null);
+      const itemNodes = [
+        ...collection.getKeys()
+      ].map((key) => {
+        const itemNode = collection.getItem(key);
+        return itemNode.type === "item" ? itemNode : null;
+      }).filter((node) => node !== null);
+      const diff = cachedItemNodes.length - itemNodes.length;
+      let index = Math.min(diff > 1 ? Math.max(startItem.index - diff + 1, 0) : startItem.index, itemNodes.length - 1);
+      let newNode;
+      while (index >= 0) {
+        if (!selectionManager.isDisabled(itemNodes[index].key)) {
+          newNode = itemNodes[index];
+          break;
+        }
+        if (index < itemNodes.length - 1)
+          index++;
+        else {
+          if (index > startItem.index)
+            index = startItem.index;
+          index--;
+        }
+      }
+      selectionState.setFocusedKey(newNode ? newNode.key : null);
+    }
+    cachedCollection.current = collection;
+  }, [
+    collection,
+    selectionManager,
+    selectionState,
+    selectionState.focusedKey
+  ]);
+  return {
+    collection,
+    disabledKeys,
+    selectionManager
+  };
+}
+export {
+  $e72dd72e1c76a225$export$2f645645f7bca764 as $
+};

package/dist/useLocalizedStringFormatter-Prmz0h0A.js

@@ -0,0 +1,130 @@
+import { $ as $18f2051aff69b9bf$export$43bb16f9c6d9e3f7 } from "./context-jMy6xdVq.js";
+import { useMemo } from "react";
+const $5b160d28a433310d$var$localeSymbol = Symbol.for("react-aria.i18n.locale");
+const $5b160d28a433310d$var$stringsSymbol = Symbol.for("react-aria.i18n.strings");
+let $5b160d28a433310d$var$cachedGlobalStrings = void 0;
+class $5b160d28a433310d$export$c17fa47878dc55b6 {
+  /** Returns a localized string for the given key and locale. */
+  getStringForLocale(key, locale) {
+    let strings = this.getStringsForLocale(locale);
+    let string = strings[key];
+    if (!string)
+      throw new Error(`Could not find intl message ${key} in ${locale} locale`);
+    return string;
+  }
+  /** Returns all localized strings for the given locale. */
+  getStringsForLocale(locale) {
+    let strings = this.strings[locale];
+    if (!strings) {
+      strings = $5b160d28a433310d$var$getStringsForLocale(locale, this.strings, this.defaultLocale);
+      this.strings[locale] = strings;
+    }
+    return strings;
+  }
+  static getGlobalDictionaryForPackage(packageName) {
+    if (typeof window === "undefined")
+      return null;
+    let locale = window[$5b160d28a433310d$var$localeSymbol];
+    if ($5b160d28a433310d$var$cachedGlobalStrings === void 0) {
+      let globalStrings = window[$5b160d28a433310d$var$stringsSymbol];
+      if (!globalStrings)
+        return null;
+      $5b160d28a433310d$var$cachedGlobalStrings = {};
+      for (let pkg in globalStrings)
+        $5b160d28a433310d$var$cachedGlobalStrings[pkg] = new $5b160d28a433310d$export$c17fa47878dc55b6({
+          [locale]: globalStrings[pkg]
+        }, locale);
+    }
+    let dictionary = $5b160d28a433310d$var$cachedGlobalStrings === null || $5b160d28a433310d$var$cachedGlobalStrings === void 0 ? void 0 : $5b160d28a433310d$var$cachedGlobalStrings[packageName];
+    if (!dictionary)
+      throw new Error(`Strings for package "${packageName}" were not included by LocalizedStringProvider. Please add it to the list passed to createLocalizedStringDictionary.`);
+    return dictionary;
+  }
+  constructor(messages, defaultLocale = "en-US") {
+    this.strings = Object.fromEntries(Object.entries(messages).filter(([, v]) => v));
+    this.defaultLocale = defaultLocale;
+  }
+}
+function $5b160d28a433310d$var$getStringsForLocale(locale, strings, defaultLocale = "en-US") {
+  if (strings[locale])
+    return strings[locale];
+  let language = $5b160d28a433310d$var$getLanguage(locale);
+  if (strings[language])
+    return strings[language];
+  for (let key in strings) {
+    if (key.startsWith(language + "-"))
+      return strings[key];
+  }
+  return strings[defaultLocale];
+}
+function $5b160d28a433310d$var$getLanguage(locale) {
+  if (Intl.Locale)
+    return new Intl.Locale(locale).language;
+  return locale.split("-")[0];
+}
+const $6db58dc88e78b024$var$pluralRulesCache = /* @__PURE__ */ new Map();
+const $6db58dc88e78b024$var$numberFormatCache = /* @__PURE__ */ new Map();
+class $6db58dc88e78b024$export$2f817fcdc4b89ae0 {
+  /** Formats a localized string for the given key with the provided variables. */
+  format(key, variables) {
+    let message = this.strings.getStringForLocale(key, this.locale);
+    return typeof message === "function" ? message(variables, this) : message;
+  }
+  plural(count, options, type = "cardinal") {
+    let opt = options["=" + count];
+    if (opt)
+      return typeof opt === "function" ? opt() : opt;
+    let key = this.locale + ":" + type;
+    let pluralRules = $6db58dc88e78b024$var$pluralRulesCache.get(key);
+    if (!pluralRules) {
+      pluralRules = new Intl.PluralRules(this.locale, {
+        type
+      });
+      $6db58dc88e78b024$var$pluralRulesCache.set(key, pluralRules);
+    }
+    let selected = pluralRules.select(count);
+    opt = options[selected] || options.other;
+    return typeof opt === "function" ? opt() : opt;
+  }
+  number(value) {
+    let numberFormat = $6db58dc88e78b024$var$numberFormatCache.get(this.locale);
+    if (!numberFormat) {
+      numberFormat = new Intl.NumberFormat(this.locale);
+      $6db58dc88e78b024$var$numberFormatCache.set(this.locale, numberFormat);
+    }
+    return numberFormat.format(value);
+  }
+  select(options, value) {
+    let opt = options[value] || options.other;
+    return typeof opt === "function" ? opt() : opt;
+  }
+  constructor(locale, strings) {
+    this.locale = locale;
+    this.strings = strings;
+  }
+}
+const $fca6afa0e843324b$var$cache = /* @__PURE__ */ new WeakMap();
+function $fca6afa0e843324b$var$getCachedDictionary(strings) {
+  let dictionary = $fca6afa0e843324b$var$cache.get(strings);
+  if (!dictionary) {
+    dictionary = new $5b160d28a433310d$export$c17fa47878dc55b6(strings);
+    $fca6afa0e843324b$var$cache.set(strings, dictionary);
+  }
+  return dictionary;
+}
+function $fca6afa0e843324b$export$87b761675e8eaa10(strings, packageName) {
+  return packageName && $5b160d28a433310d$export$c17fa47878dc55b6.getGlobalDictionaryForPackage(packageName) || $fca6afa0e843324b$var$getCachedDictionary(strings);
+}
+function $fca6afa0e843324b$export$f12b703ca79dfbb1(strings, packageName) {
+  let { locale } = $18f2051aff69b9bf$export$43bb16f9c6d9e3f7();
+  let dictionary = $fca6afa0e843324b$export$87b761675e8eaa10(strings, packageName);
+  return useMemo(() => new $6db58dc88e78b024$export$2f817fcdc4b89ae0(locale, dictionary), [
+    locale,
+    dictionary
+  ]);
+}
+export {
+  $fca6afa0e843324b$export$f12b703ca79dfbb1 as $,
+  $5b160d28a433310d$export$c17fa47878dc55b6 as a,
+  $6db58dc88e78b024$export$2f817fcdc4b89ae0 as b
+};