@estuary-solutions/rn-core-ui 0.0.4 → 0.1.0

package/src/theme/useTheme.ts

@@ -0,0 +1,45 @@
+import React from 'react';
+import { useColorScheme } from 'react-native';
+
+import { ThemeContext } from './ThemeProvider';
+import type { ColorScheme, SchemePreference, Theme, ThemeValue } from './types';
+
+const valueCache = new WeakMap<
+  Theme,
+  Partial<Record<ColorScheme, ThemeValue>>
+>();
+
+/**
+ * The object useTheme() hands out for a theme and scheme. Cached so its identity is
+ * stable across renders, which useStyles relies on for its own cache.
+ */
+export function getThemeValue(theme: Theme, scheme: ColorScheme): ThemeValue {
+  let perScheme = valueCache.get(theme);
+  if (!perScheme) {
+    perScheme = {};
+    valueCache.set(theme, perScheme);
+  }
+  let value = perScheme[scheme];
+  if (!value) {
+    value = { ...theme[scheme], name: theme.name, scheme };
+    perScheme[scheme] = value;
+  }
+  return value;
+}
+
+export function resolveScheme(
+  preference: SchemePreference,
+  osScheme: ReturnType<typeof useColorScheme>,
+): ColorScheme {
+  if (preference === 'system') {
+    return osScheme === 'dark' ? 'dark' : 'light';
+  }
+  return preference;
+}
+
+/** Tokens of the active scheme plus `name` and `scheme`. */
+export function useTheme(): ThemeValue {
+  const { theme, preference } = React.useContext(ThemeContext);
+  const osScheme = useColorScheme();
+  return getThemeValue(theme, resolveScheme(preference, osScheme));
+}

package/src/utils/DraggableFlatList/typedMemo.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+
+export const typedMemo: <T>(c: T) => T = React.memo;

package/src/utils/ImageView/index.ts

@@ -0,0 +1,165 @@
+import {
+  Animated,
+  GestureResponderEvent,
+  PanResponder,
+  PanResponderGestureState,
+  PanResponderInstance,
+  NativeTouchEvent,
+} from 'react-native';
+
+import { Dimensions, Position } from '../../Images/ImageView/types';
+import { windowHeight as height, windowWidth as width } from './window';
+
+type CacheStorageItem = { key: string; value: any };
+
+export const createCache = (cacheSize: number) => ({
+  _storage: [] as CacheStorageItem[],
+  get(key: string): any {
+    const { value } =
+      this._storage.find(({ key: storageKey }) => storageKey === key) || {};
+
+    return value;
+  },
+  set(key: string, value: any) {
+    if (this._storage.length >= cacheSize) {
+      this._storage.shift();
+    }
+
+    this._storage.push({ key, value });
+  },
+});
+
+export const splitArrayIntoBatches = (arr: any[], batchSize: number): any[] =>
+  arr.reduce((result, item) => {
+    const batch = result.pop() || [];
+
+    if (batch.length < batchSize) {
+      batch.push(item);
+      result.push(batch);
+    } else {
+      result.push(batch, [item]);
+    }
+
+    return result;
+  }, []);
+
+export const getImageTransform = (image: Dimensions | null) => {
+  if (!image?.width || !image?.height) {
+    return [] as const;
+  }
+
+  const wScale = width / image.width;
+  const hScale = height / image.height;
+  const scale = Math.min(wScale, hScale);
+  const { x, y } = getImageTranslate(image);
+
+  return [{ x, y }, scale] as const;
+};
+
+export const getImageStyles = (
+  image: Dimensions | null,
+  translate: Animated.ValueXY,
+  scale?: Animated.Value,
+) => {
+  if (!image?.width || !image?.height) {
+    return { width: 0, height: 0 };
+  }
+
+  const transform = translate.getTranslateTransform();
+
+  if (scale) {
+    transform.push(
+      { scale } as any,
+      { perspective: new Animated.Value(1000) } as any,
+    );
+  }
+
+  return {
+    width: image.width,
+    height: image.height,
+    transform,
+  };
+};
+
+export const getImageTranslate = (image: Dimensions): Position => {
+  const getTranslateForAxis = (axis: 'x' | 'y'): number => {
+    const imageSize = axis === 'x' ? image.width : image.height;
+    const screenSize = axis === 'x' ? width : height;
+
+    return (screenSize - imageSize) / 2;
+  };
+
+  return {
+    x: getTranslateForAxis('x'),
+    y: getTranslateForAxis('y'),
+  };
+};
+
+export const getImageDimensionsByTranslate = (
+  translate: Position,
+): Dimensions => ({
+  width: width - translate.x * 2,
+  height: height - translate.y * 2,
+});
+
+export const getImageTranslateForScale = (
+  currentTranslate: Position,
+  targetScale: number,
+): Position => {
+  const { width, height } = getImageDimensionsByTranslate(currentTranslate);
+
+  const targetImageDimensions = {
+    width: width * targetScale,
+    height: height * targetScale,
+  };
+
+  return getImageTranslate(targetImageDimensions);
+};
+
+type HandlerType = (
+  event: GestureResponderEvent,
+  state: PanResponderGestureState,
+) => void;
+
+type PanResponderProps = {
+  onGrant: HandlerType;
+  onStart?: HandlerType;
+  onMove: HandlerType;
+  onRelease?: HandlerType;
+  onTerminate?: HandlerType;
+};
+
+export const createPanResponder = ({
+  onGrant,
+  onStart,
+  onMove,
+  onRelease,
+  onTerminate,
+}: PanResponderProps): PanResponderInstance =>
+  PanResponder.create({
+    onStartShouldSetPanResponder: () => true,
+    onStartShouldSetPanResponderCapture: () => true,
+    onMoveShouldSetPanResponder: () => true,
+    onMoveShouldSetPanResponderCapture: () => true,
+    onPanResponderGrant: onGrant,
+    onPanResponderStart: onStart,
+    onPanResponderMove: onMove,
+    onPanResponderRelease: onRelease,
+    onPanResponderTerminate: onTerminate,
+    onPanResponderTerminationRequest: () => false,
+    onShouldBlockNativeResponder: () => false,
+  });
+
+export const getDistanceBetweenTouches = (
+  touches: NativeTouchEvent[],
+): number => {
+  const [a, b] = touches;
+
+  if (a == null || b == null) {
+    return 0;
+  }
+
+  return Math.sqrt(
+    Math.pow(a.pageX - b.pageX, 2) + Math.pow(a.pageY - b.pageY, 2),
+  );
+};

package/src/utils/ImageView/window.ts

@@ -0,0 +1,8 @@
+import { Dimensions } from 'react-native';
+
+// Window size for the full-screen image viewer, read once like the vendored
+// react-native-image-viewing it derives from. Internal to ImageView; components
+// use useWindowDimensions() instead.
+const { width: windowWidth, height: windowHeight } = Dimensions.get('window');
+
+export { windowHeight, windowWidth };

package/src/utils/cleanTagHTML.ts

@@ -0,0 +1,36 @@
+/**
+ * Provide a function to clean HTML tags and   from a string.
+ *
+ * @example
+ * ```js
+ * import { cleanHTML } from '@estuary-solutions/rn-core-ui/utils';
+ *
+ * const raw = `
+ *   <div>Hello&nbsp;&nbsp;&nbsp;World</div>
+ *   <p>This is&nbsp;a <strong>test</strong></p>
+ * `;
+ *
+ * console.log(cleanHTML(raw));
+ * // Output:
+ * // Hello
+ * // World
+ * // This is a test
+ * ```
+ */
+export default (str: string = '') => {
+  if (str && str.trim().length) {
+    let data = [];
+    let arr = str.replace(/<\/?[^>]+(>|$)/g, '').split('&nbsp;');
+
+    // break one line when multiple &nbsp;
+    for (let i = 0; i < arr.length; i++) {
+      if (arr[i] && arr[i].trim()) {
+        data.push(arr[i]);
+      } else if (arr[i - 1] && arr[i - 1].trim()) {
+        data.push('\n');
+      }
+    }
+    return data.join('');
+  }
+  return '';
+};

package/src/utils/converter.ts

@@ -0,0 +1,57 @@
+/**
+ * This function converts input into a string.
+ * * If the input is null or undefined, it returns an empty string.
+ * * If the input is an object, it returns a stringified version of the object.
+ * * Otherwise, it returns the string representation of the input.
+ * @example
+ * ```js
+ * import { convertString } from '@estuary-solutions/rn-core-ui/utils';
+ * const str = convertString(2003); // "2003"
+ * ```
+ */
+export const convertString = (value: any) => {
+  return String(value);
+};
+
+/**
+ * This function converts input into a number.
+ * * If the input is null or undefined, it returns 0.
+ * * If the input is not a number, it returns 0.
+ * * Otherwise, it returns the parsed float value of the input.
+ * @example
+ * ```js
+ * import { convertNumber } from '@estuary-solutions/rn-core-ui/utils';
+ * const num = convertNumber("2003"); // 2003
+ * ```
+ */
+export const convertNumber = (value: any) => {
+  return isNaN(parseFloat(value)) ? 0 : parseFloat(value);
+};
+
+/**
+ * Function to convert seconds to a string in the format "mm:ss".
+ * * If the input is less than 0, it returns "00:00".
+ * * If the input is greater than 3599, it returns "00:00".
+ * @example
+ * ```js
+ * import { convertSeconds } from '@estuary-solutions/rn-core-ui/utils';
+ * const time = convertSeconds(123); // "02:03"
+ * ```
+ */
+export const convertSeconds = (seconds: number = 0) => {
+  return new Date(Math.max(seconds, 0) * 1000).toISOString().substr(14, 5);
+};
+
+/**
+ * Function to format seconds into a string in the format "hh:mm:ss".
+ * * If the input is less than 0, it returns "00:00:00".
+ * * If the input is greater than 86399, it returns "00:00:00".
+ * @example
+ * ```js
+ * import { formatHour } from '@estuary-solutions/rn-core-ui/utils';
+ * const time = formatHour(3661); // "01:01:01"
+ * ```
+ */
+export const formatHour = (seconds: number = 0) => {
+  return new Date(Math.max(seconds, 0) * 1000).toISOString().substr(11, 8);
+};

package/src/utils/debounce.ts

@@ -0,0 +1,69 @@
+export type DebouncedFunction<F extends (...args: any[]) => any> = {
+  (...args: Parameters<F>): void;
+  cancel: () => void;
+  flush: () => void;
+};
+
+/**
+ * - Creates a debounced function that delays invoking the provided function until after
+ * a specified delay in milliseconds has elapsed since the last time the debounced
+ * function was invoked.
+ * - The debounced function comes with `cancel` and `flush` methods to cancel the
+ * debounced invocation and to immediately invoke the function, respectively.
+ * @example
+ * ```jsx
+ * import { debounce } from '@estuary-solutions/rn-core-ui/utils';
+ * const onChangeText = debounce(() => {
+ *   console.log('Function executed!');
+ * }, 1000);
+ *
+ * //Flush case
+ * const debouncedLog = debounce(logMessage, 2000);
+ *
+ * debouncedLog("Waiting 2s...");
+ * setTimeout(() => {
+ *   debouncedLog.flush(); // Immediately execute the function
+ * }, 1000);
+ *
+ * //Cancel case
+ * debouncedLog("Canceled");
+ * setTimeout(() => {
+ *   debouncedLog.cancel(); // Don't execute the function
+ * }, 1000);
+ * ```
+ */
+const debounce = <F extends (...args: any[]) => any>(
+  func: F,
+  delay: number,
+): DebouncedFunction<F> => {
+  let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+  const debounced = (...args: Parameters<F>) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+
+    timeoutId = setTimeout(() => {
+      func(...args);
+    }, delay);
+  };
+
+  debounced.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+
+  debounced.flush = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      func();
+      timeoutId = null;
+    }
+  };
+
+  return debounced;
+};
+
+export default debounce;

package/src/utils/filters.ts

@@ -0,0 +1,13 @@
+import { TextStyle } from 'react-native';
+
+const ALLOWED_STYLE_KEYS = ['color', 'fontFamily', 'fontWeight'] as const;
+
+export const filterAllowedTextStyle = (style: any): Partial<TextStyle> => {
+  const filtered: Partial<TextStyle> = {};
+  for (const key of ALLOWED_STYLE_KEYS) {
+    if (key in style) {
+      filtered[key] = style[key];
+    }
+  }
+  return filtered;
+};

package/src/utils/fixedDistance.ts

@@ -0,0 +1,19 @@
+/**
+ * Function to format a distance value.
+ * - If the input is an integer, it returns the integer value.
+ * - If the input is a float, it returns the value formatted to a custom toFixed value decimal places.
+ * - If the input is null or undefined, it returns 0.
+ *
+ * *Note:* The toFixed value should be between 1 and 5, otherwise it defaults to 2.
+ * @example
+ * ```js
+ * import { fixedDistance } from '@estuary-solutions/rn-core-ui/utils';
+ * const distance = fixedDistance(123.456); // "123.46"
+ * ```
+ */
+export default (distance: number = 0, toFixed: number = 2) => {
+  const toFixedVal = toFixed < 1 || toFixed > 5 ? 2 : toFixed;
+  return Number.isInteger(Number(distance))
+    ? distance
+    : distance?.toFixed(toFixedVal);
+};

package/src/utils/formatMoney.ts

@@ -0,0 +1,37 @@
+/**
+ * Function to format money values.
+ *
+ * `num` - The number to format. Default is 0.
+ *
+ * `maximumFractionDigits` - The maximum number of decimal places to display. Default is 0.
+ *
+ * `lang`
+ * * The locale to use for formatting. Default is 'en-US'.
+ * * This should be a BCP 47 language tag (e.g., 'en-US', 'vi-VN').
+ * * This is a string that contains a language code and an optional country code, separated by a hyphen.
+ * * Structure: `"[languageCode]-[countryCode]"`
+ *
+ * @example
+ * ```js
+ * import { formatMoney } from '@estuary-solutions/rn-core-ui/utils';
+ * const money = formatMoney(1234567.89); // "1,234,568"
+ * const money2 = formatMoney(1234567.89, 2); // "1,234,567.89"
+ * const money3 = formatMoney(1234567.89, 2, 'vi-VN'); // "1.234.567,89"
+ * ```
+ *
+ * To get more information. Please see the [Documentation](https://lubrytics.com:9929/minhnhat.tran/estuary-rn-core-ui?tab=readme-ov-file#formatmoney)
+ *
+ * *Reference:*
+ * - [List of ISO 639 language codes](https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes)
+ * - [List of ISO 3166-1 country codes](https://vi.wikipedia.org/wiki/ISO_3166-1)
+ */
+export default (
+  num: number = 0,
+  maximumFractionDigits: number = 0,
+  lang: string = 'en-US',
+) => {
+  if (!num) {
+    return 0;
+  }
+  return new Intl.NumberFormat(lang, { maximumFractionDigits }).format(num);
+};

package/src/utils/getOS.ts

@@ -0,0 +1,7 @@
+import { Platform } from 'react-native';
+
+export const ANDROID = Platform.OS === 'android';
+export const IOS = Platform.OS === 'ios';
+export const MACOS = Platform.OS === 'macos';
+export const WEB = Platform.OS === 'web';
+export const WINDOWS = Platform.OS === 'windows';

package/src/utils/index.ts

@@ -0,0 +1,35 @@
+// Non-UI helpers kept after ADR-0001. Sizing comes from theme tokens and
+// useWindowDimensions(); the old width-based scale() helpers are gone.
+import { filterAllowedTextStyle } from './filters';
+import cleanTagHTML from './cleanTagHTML';
+import {
+  convertString,
+  convertNumber,
+  convertSeconds,
+  formatHour,
+} from './converter';
+import debounce from './debounce';
+import fixedDistance from './fixedDistance';
+import formatMoney from './formatMoney';
+import limitedString from './limitedString';
+import { IOS, ANDROID, MACOS, WEB, WINDOWS } from './getOS';
+
+export { sum } from './sum';
+
+export {
+  filterAllowedTextStyle,
+  cleanTagHTML,
+  convertString,
+  convertNumber,
+  convertSeconds,
+  formatHour,
+  debounce,
+  fixedDistance,
+  formatMoney,
+  limitedString,
+  IOS,
+  ANDROID,
+  MACOS,
+  WEB,
+  WINDOWS,
+};

package/src/utils/limitedString.ts

@@ -0,0 +1,19 @@
+/**
+ * Function to limit the number of words in a string.
+ * @param {string} str - The string to limit. *Default:* str = ''
+ * @param {number} maxLength - The maximum number of words allowed. *Default:* maxLength = 5
+ * @returns {string} - The limited string
+ * @example
+ * ```js
+ * import { limitedString } from '@estuary-solutions/rn-core-ui/utils';
+ * const inputString  = "Lorem Ipsum is simply dummy text of the printing and typesetting industry";
+ * console.log(limitedString(inputString)); // "Lorem Ipsum is simply dummy..."
+ * ```
+ */
+export default (str: string = '', maxLength: number = 5): string => {
+  let arr = str.split(' ');
+  if (arr.length > maxLength) {
+    return arr.slice(0, maxLength).join(' ') + '...';
+  }
+  return str;
+};

package/src/utils/sum.ts

@@ -0,0 +1,6 @@
+export const sum = (array: number[], initialValue: number = 0) => {
+  return array.reduce(
+    (accumulator, currentValue) => accumulator + currentValue,
+    initialValue,
+  );
+};

package/dist/Accordion/Accordion.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Accordion.d.ts","sourceRoot":"","sources":["../../src/Accordion/Accordion.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAQ1B,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,QAAA,MAAM,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,cAAc,CAwCvC,CAAC;AAIF,eAAe,SAAS,CAAC"}

package/dist/Accordion/Accordion.js

@@ -1,19 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React from 'react';
-import { Pressable, View } from 'react-native';
-import Animated, { FadeIn, FadeOut, LinearTransition, } from 'react-native-reanimated';
-const Accordion = ({ header, children, expanded, defaultExpanded = false, onChange, style, disabled, }) => {
-    const isControlled = expanded !== undefined;
-    const [internalExpanded, setInternalExpanded] = React.useState(defaultExpanded);
-    const isExpanded = isControlled ? expanded : internalExpanded;
-    const toggle = React.useCallback(() => {
-        const next = !isExpanded;
-        if (!isControlled) {
-            setInternalExpanded(next);
-        }
-        onChange === null || onChange === void 0 ? void 0 : onChange(next);
-    }, [isExpanded, isControlled, onChange]);
-    return (_jsxs(View, { style: style, children: [_jsx(Pressable, { disabled: disabled, onPress: toggle, children: header }), isExpanded && (_jsx(Animated.View, { entering: FadeIn, exiting: FadeOut, layout: LinearTransition.springify(), children: children }))] }));
-};
-Accordion.displayName = 'Accordion';
-export default Accordion;

package/dist/Accordion/AccordionContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AccordionContext.d.ts","sourceRoot":"","sources":["../../src/Accordion/AccordionContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,MAAM,WAAW,2BAA2B;IAC1C,eAAe,EAAE,MAAM,IAAI,CAAC;CAC7B;AAED,eAAO,MAAM,sBAAsB,mDAC4B,CAAC;AAEhE,eAAO,MAAM,kBAAkB,0CACW,CAAC"}

package/dist/Accordion/AccordionContext.js

@@ -1,3 +0,0 @@
-import React from 'react';
-export const AccordionLayoutContext = React.createContext(null);
-export const useAccordionLayout = () => React.useContext(AccordionLayoutContext);

package/dist/Accordion/AccordionGroup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AccordionGroup.d.ts","sourceRoot":"","sources":["../../src/Accordion/AccordionGroup.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAAE,0BAA0B,EAAE,mBAAmB,EAAe,MAAM,wBAAwB,CAAC;AAKtG,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAgCjD,CAAC;AAEF,eAAO,MAAM,iBAAiB,kCAM7B,CAAC;AAEF,eAAO,MAAM,yBAAyB,yCAErC,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/Accordion/AccordionGroup.js

@@ -1,32 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import React from 'react';
-const AccordionGroupContext = React.createContext(null);
-const AccordionGroup = ({ children, type = 'single', defaultOpenIds = [], }) => {
-    const [openIds, setOpenIds] = React.useState(() => new Set(defaultOpenIds));
-    const toggle = React.useCallback((id) => {
-        setOpenIds(prev => {
-            const next = new Set(prev);
-            if (type === 'single') {
-                next.clear();
-                if (!prev.has(id))
-                    next.add(id);
-            }
-            else {
-                next.has(id) ? next.delete(id) : next.add(id);
-            }
-            return next;
-        });
-    }, [type]);
-    return (_jsx(AccordionGroupContext.Provider, { value: { openIds, toggle }, children: children }));
-};
-export const useAccordionGroup = () => {
-    const ctx = React.useContext(AccordionGroupContext);
-    if (!ctx) {
-        throw new Error('Accordion must be used inside AccordionGroup');
-    }
-    return ctx;
-};
-export const useOptionalAccordionGroup = () => {
-    return React.useContext(AccordionGroupContext);
-};
-export default AccordionGroup;

package/dist/Accordion/AccordionItem.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AccordionItem.d.ts","sourceRoot":"","sources":["../../src/Accordion/AccordionItem.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CA0B/C,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/Accordion/AccordionItem.js

@@ -1,12 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import Accordion from './Accordion';
-import { useAccordionGroup } from './AccordionGroup';
-const AccordionItem = ({ id, header, children, style, disabled, onChange, }) => {
-    const { openIds, toggle } = useAccordionGroup();
-    const expanded = openIds.has(id);
-    return (_jsx(Accordion, { header: header, expanded: expanded, onChange: (ex) => {
-            toggle(id);
-            onChange && onChange(ex);
-        }, style: style, disabled: disabled, children: children }));
-};
-export default AccordionItem;

package/dist/Accordion/AccordionTree.d.ts

@@ -1,6 +0,0 @@
-declare const AccordionTree: import("react").FC<import("./types/AccordionTypes").AccordionTreeProps & {
-    renderItem?: (params: import("./types/AccordionTypes").AccordionTreeItemProps) => React.ReactNode;
-    renderRootItem?: (params: import("./types/AccordionTypes").AccordionTreeItemProps) => React.ReactNode;
-}>;
-export default AccordionTree;
-//# sourceMappingURL=AccordionTree.d.ts.map

package/dist/Accordion/AccordionTree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AccordionTree.d.ts","sourceRoot":"","sources":["../../src/Accordion/AccordionTree.tsx"],"names":[],"mappings":"AAEA,QAAA,MAAM,aAAa;;;EAAyB,CAAC;AAI7C,eAAe,aAAa,CAAC"}

package/dist/Accordion/AccordionTree.js

@@ -1,4 +0,0 @@
-import AccordionTreeWithGroup from "./AccordionTreeWithGroup";
-const AccordionTree = AccordionTreeWithGroup;
-AccordionTree.displayName = 'AccordionTree';
-export default AccordionTree;

package/dist/Accordion/AccordionTreeInternal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AccordionTreeInternal.d.ts","sourceRoot":"","sources":["../../src/Accordion/AccordionTreeInternal.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B,OAAO,EAGL,kBAAkB,EAClB,0BAA0B,EAE3B,MAAM,wBAAwB,CAAC;AAMhC,QAAA,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CACnC,0BAA0B,GAC1B,IAAI,CACF,kBAAkB,EAChB,MAAM,GACN,OAAO,GACP,WAAW,GACX,eAAe,GACf,YAAY,GACZ,gBAAgB,GAChB,cAAc,CACjB,CA+EF,CAAC;AAEF,eAAe,qBAAqB,CAAC"}