@arc-ui/components 12.0.0-beta.13 → 12.0.0-beta.14.1

package/lib/_shared/cjs/index-DR8Rkav9.cjs

@@ -0,0 +1,130 @@
+'use strict';
+
+var index = require('./index-CTlXMLug.cjs');
+
+var camelcase$1 = {exports: {}};
+
+var hasRequiredCamelcase;
+
+function requireCamelcase () {
+	if (hasRequiredCamelcase) return camelcase$1.exports;
+	hasRequiredCamelcase = 1;
+
+	const UPPERCASE = /[\p{Lu}]/u;
+	const LOWERCASE = /[\p{Ll}]/u;
+	const LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
+	const IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
+	const SEPARATORS = /[_.\- ]+/;
+
+	const LEADING_SEPARATORS = new RegExp('^' + SEPARATORS.source);
+	const SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, 'gu');
+	const NUMBERS_AND_IDENTIFIER = new RegExp('\\d+' + IDENTIFIER.source, 'gu');
+
+	const preserveCamelCase = (string, toLowerCase, toUpperCase) => {
+		let isLastCharLower = false;
+		let isLastCharUpper = false;
+		let isLastLastCharUpper = false;
+
+		for (let i = 0; i < string.length; i++) {
+			const character = string[i];
+
+			if (isLastCharLower && UPPERCASE.test(character)) {
+				string = string.slice(0, i) + '-' + string.slice(i);
+				isLastCharLower = false;
+				isLastLastCharUpper = isLastCharUpper;
+				isLastCharUpper = true;
+				i++;
+			} else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character)) {
+				string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
+				isLastLastCharUpper = isLastCharUpper;
+				isLastCharUpper = false;
+				isLastCharLower = true;
+			} else {
+				isLastCharLower = toLowerCase(character) === character && toUpperCase(character) !== character;
+				isLastLastCharUpper = isLastCharUpper;
+				isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character;
+			}
+		}
+
+		return string;
+	};
+
+	const preserveConsecutiveUppercase = (input, toLowerCase) => {
+		LEADING_CAPITAL.lastIndex = 0;
+
+		return input.replace(LEADING_CAPITAL, m1 => toLowerCase(m1));
+	};
+
+	const postProcess = (input, toUpperCase) => {
+		SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
+		NUMBERS_AND_IDENTIFIER.lastIndex = 0;
+
+		return input.replace(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier))
+			.replace(NUMBERS_AND_IDENTIFIER, m => toUpperCase(m));
+	};
+
+	const camelCase = (input, options) => {
+		if (!(typeof input === 'string' || Array.isArray(input))) {
+			throw new TypeError('Expected the input to be `string | string[]`');
+		}
+
+		options = {
+			pascalCase: false,
+			preserveConsecutiveUppercase: false,
+			...options
+		};
+
+		if (Array.isArray(input)) {
+			input = input.map(x => x.trim())
+				.filter(x => x.length)
+				.join('-');
+		} else {
+			input = input.trim();
+		}
+
+		if (input.length === 0) {
+			return '';
+		}
+
+		const toLowerCase = options.locale === false ?
+			string => string.toLowerCase() :
+			string => string.toLocaleLowerCase(options.locale);
+		const toUpperCase = options.locale === false ?
+			string => string.toUpperCase() :
+			string => string.toLocaleUpperCase(options.locale);
+
+		if (input.length === 1) {
+			return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
+		}
+
+		const hasUpperCase = input !== toLowerCase(input);
+
+		if (hasUpperCase) {
+			input = preserveCamelCase(input, toLowerCase, toUpperCase);
+		}
+
+		input = input.replace(LEADING_SEPARATORS, '');
+
+		if (options.preserveConsecutiveUppercase) {
+			input = preserveConsecutiveUppercase(input, toLowerCase);
+		} else {
+			input = toLowerCase(input);
+		}
+
+		if (options.pascalCase) {
+			input = toUpperCase(input.charAt(0)) + input.slice(1);
+		}
+
+		return postProcess(input, toUpperCase);
+	};
+
+	camelcase$1.exports = camelCase;
+	// TODO: Remove this for the next major release
+	camelcase$1.exports.default = camelCase;
+	return camelcase$1.exports;
+}
+
+var camelcaseExports = requireCamelcase();
+var camelcase = /*@__PURE__*/index.getDefaultExportFromCjs(camelcaseExports);
+
+exports.camelcase = camelcase;

package/lib/_shared/cjs/index-DXNM3D1d.cjs

@@ -0,0 +1,196 @@
+'use strict';
+
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+var useThemeElement = function () {
+    var _a = React.useState(undefined), themeElement = _a[0], setElement = _a[1];
+    var setThemeElement = function (el) {
+        el &&
+            setElement(el.closest(".arc-ds-sys-theme") || undefined);
+    };
+    return [themeElement, setThemeElement];
+};
+
+// packages/react/context/src/createContext.tsx
+function createContext2(rootComponentName, defaultContext) {
+  const Context = React__namespace.createContext(defaultContext);
+  const Provider = (props) => {
+    const { children, ...context } = props;
+    const value = React__namespace.useMemo(() => context, Object.values(context));
+    return /* @__PURE__ */ jsxRuntime.jsx(Context.Provider, { value, children });
+  };
+  Provider.displayName = rootComponentName + "Provider";
+  function useContext2(consumerName) {
+    const context = React__namespace.useContext(Context);
+    if (context) return context;
+    if (defaultContext !== void 0) return defaultContext;
+    throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+  }
+  return [Provider, useContext2];
+}
+function createContextScope(scopeName, createContextScopeDeps = []) {
+  let defaultContexts = [];
+  function createContext3(rootComponentName, defaultContext) {
+    const BaseContext = React__namespace.createContext(defaultContext);
+    const index = defaultContexts.length;
+    defaultContexts = [...defaultContexts, defaultContext];
+    const Provider = (props) => {
+      const { scope, children, ...context } = props;
+      const Context = scope?.[scopeName]?.[index] || BaseContext;
+      const value = React__namespace.useMemo(() => context, Object.values(context));
+      return /* @__PURE__ */ jsxRuntime.jsx(Context.Provider, { value, children });
+    };
+    Provider.displayName = rootComponentName + "Provider";
+    function useContext2(consumerName, scope) {
+      const Context = scope?.[scopeName]?.[index] || BaseContext;
+      const context = React__namespace.useContext(Context);
+      if (context) return context;
+      if (defaultContext !== void 0) return defaultContext;
+      throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+    }
+    return [Provider, useContext2];
+  }
+  const createScope = () => {
+    const scopeContexts = defaultContexts.map((defaultContext) => {
+      return React__namespace.createContext(defaultContext);
+    });
+    return function useScope(scope) {
+      const contexts = scope?.[scopeName] || scopeContexts;
+      return React__namespace.useMemo(
+        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),
+        [scope, contexts]
+      );
+    };
+  };
+  createScope.scopeName = scopeName;
+  return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];
+}
+function composeContextScopes(...scopes) {
+  const baseScope = scopes[0];
+  if (scopes.length === 1) return baseScope;
+  const createScope = () => {
+    const scopeHooks = scopes.map((createScope2) => ({
+      useScope: createScope2(),
+      scopeName: createScope2.scopeName
+    }));
+    return function useComposedScopes(overrideScopes) {
+      const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {
+        const scopeProps = useScope(overrideScopes);
+        const currentScope = scopeProps[`__scope${scopeName}`];
+        return { ...nextScopes2, ...currentScope };
+      }, {});
+      return React__namespace.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
+    };
+  };
+  createScope.scopeName = baseScope.scopeName;
+  return createScope;
+}
+
+// packages/react/use-callback-ref/src/useCallbackRef.tsx
+function useCallbackRef(callback) {
+  const callbackRef = React__namespace.useRef(callback);
+  React__namespace.useEffect(() => {
+    callbackRef.current = callback;
+  });
+  return React__namespace.useMemo(() => (...args) => callbackRef.current?.(...args), []);
+}
+
+// packages/react/use-escape-keydown/src/useEscapeKeydown.tsx
+function useEscapeKeydown(onEscapeKeyDownProp, ownerDocument = globalThis?.document) {
+  const onEscapeKeyDown = useCallbackRef(onEscapeKeyDownProp);
+  React__namespace.useEffect(() => {
+    const handleKeyDown = (event) => {
+      if (event.key === "Escape") {
+        onEscapeKeyDown(event);
+      }
+    };
+    ownerDocument.addEventListener("keydown", handleKeyDown, { capture: true });
+    return () => ownerDocument.removeEventListener("keydown", handleKeyDown, { capture: true });
+  }, [onEscapeKeyDown, ownerDocument]);
+}
+
+// packages/react/use-layout-effect/src/useLayoutEffect.tsx
+var useLayoutEffect2 = Boolean(globalThis?.document) ? React__namespace.useLayoutEffect : () => {
+};
+
+// packages/react/id/src/id.tsx
+var useReactId = React__namespace["useId".toString()] || (() => void 0);
+var count = 0;
+function useId(deterministicId) {
+  const [id, setId] = React__namespace.useState(useReactId());
+  useLayoutEffect2(() => {
+    if (!deterministicId) setId((reactId) => reactId ?? String(count++));
+  }, [deterministicId]);
+  return deterministicId || (id ? `radix-${id}` : "");
+}
+
+// packages/react/use-controllable-state/src/useControllableState.tsx
+function useControllableState({
+  prop,
+  defaultProp,
+  onChange = () => {
+  }
+}) {
+  const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState({ defaultProp, onChange });
+  const isControlled = prop !== void 0;
+  const value = isControlled ? prop : uncontrolledProp;
+  const handleChange = useCallbackRef(onChange);
+  const setValue = React__namespace.useCallback(
+    (nextValue) => {
+      if (isControlled) {
+        const setter = nextValue;
+        const value2 = typeof nextValue === "function" ? setter(prop) : nextValue;
+        if (value2 !== prop) handleChange(value2);
+      } else {
+        setUncontrolledProp(nextValue);
+      }
+    },
+    [isControlled, prop, setUncontrolledProp, handleChange]
+  );
+  return [value, setValue];
+}
+function useUncontrolledState({
+  defaultProp,
+  onChange
+}) {
+  const uncontrolledState = React__namespace.useState(defaultProp);
+  const [value] = uncontrolledState;
+  const prevValueRef = React__namespace.useRef(value);
+  const handleChange = useCallbackRef(onChange);
+  React__namespace.useEffect(() => {
+    if (prevValueRef.current !== value) {
+      handleChange(value);
+      prevValueRef.current = value;
+    }
+  }, [value, prevValueRef, handleChange]);
+  return uncontrolledState;
+}
+
+exports.createContext2 = createContext2;
+exports.createContextScope = createContextScope;
+exports.useCallbackRef = useCallbackRef;
+exports.useControllableState = useControllableState;
+exports.useEscapeKeydown = useEscapeKeydown;
+exports.useId = useId;
+exports.useLayoutEffect2 = useLayoutEffect2;
+exports.useThemeElement = useThemeElement;

package/lib/_shared/cjs/index-DmvtEa22.cjs

@@ -0,0 +1,219 @@
+'use strict';
+
+var React = require('react');
+var index = require('./index-CztwwwKE.cjs');
+var ReactDOM = require('react-dom');
+
+// We have resorted to returning slots directly rather than exposing primitives that can then
+// be slotted like `<CollectionItem as={Slot}>…</CollectionItem>`.
+// This is because we encountered issues with generic types that cannot be statically analysed
+// due to creating them dynamically via createCollection.
+function $e02a7d9cb1dc128c$export$c74125a8e3af6bb2(name) {
+    /* -----------------------------------------------------------------------------------------------
+   * CollectionProvider
+   * ---------------------------------------------------------------------------------------------*/ const PROVIDER_NAME = name + 'CollectionProvider';
+    const [createCollectionContext, createCollectionScope] = index.$c512c27ab02ef895$export$50c7b4e9d9f19c1(PROVIDER_NAME);
+    const [CollectionProviderImpl, useCollectionContext] = createCollectionContext(PROVIDER_NAME, {
+        collectionRef: {
+            current: null
+        },
+        itemMap: new Map()
+    });
+    const CollectionProvider = (props)=>{
+        const { scope: scope , children: children  } = props;
+        const ref = React.useRef(null);
+        const itemMap = React.useRef(new Map()).current;
+        return /*#__PURE__*/ React.createElement(CollectionProviderImpl, {
+            scope: scope,
+            itemMap: itemMap,
+            collectionRef: ref
+        }, children);
+    };
+    /* -----------------------------------------------------------------------------------------------
+   * CollectionSlot
+   * ---------------------------------------------------------------------------------------------*/ const COLLECTION_SLOT_NAME = name + 'CollectionSlot';
+    const CollectionSlot = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
+        const { scope: scope , children: children  } = props;
+        const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);
+        const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, context.collectionRef);
+        return /*#__PURE__*/ React.createElement(index.$5e63c961fc1ce211$export$8c6ed5c666ac1360, {
+            ref: composedRefs
+        }, children);
+    });
+    /* -----------------------------------------------------------------------------------------------
+   * CollectionItem
+   * ---------------------------------------------------------------------------------------------*/ const ITEM_SLOT_NAME = name + 'CollectionItemSlot';
+    const ITEM_DATA_ATTR = 'data-radix-collection-item';
+    const CollectionItemSlot = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
+        const { scope: scope , children: children , ...itemData } = props;
+        const ref = React.useRef(null);
+        const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, ref);
+        const context = useCollectionContext(ITEM_SLOT_NAME, scope);
+        React.useEffect(()=>{
+            context.itemMap.set(ref, {
+                ref: ref,
+                ...itemData
+            });
+            return ()=>void context.itemMap.delete(ref)
+            ;
+        });
+        return /*#__PURE__*/ React.createElement(index.$5e63c961fc1ce211$export$8c6ed5c666ac1360, {
+            [ITEM_DATA_ATTR]: '',
+            ref: composedRefs
+        }, children);
+    });
+    /* -----------------------------------------------------------------------------------------------
+   * useCollection
+   * ---------------------------------------------------------------------------------------------*/ function useCollection(scope) {
+        const context = useCollectionContext(name + 'CollectionConsumer', scope);
+        const getItems = React.useCallback(()=>{
+            const collectionNode = context.collectionRef.current;
+            if (!collectionNode) return [];
+            const orderedNodes = Array.from(collectionNode.querySelectorAll(`[${ITEM_DATA_ATTR}]`));
+            const items = Array.from(context.itemMap.values());
+            const orderedItems = items.sort((a, b)=>orderedNodes.indexOf(a.ref.current) - orderedNodes.indexOf(b.ref.current)
+            );
+            return orderedItems;
+        }, [
+            context.collectionRef,
+            context.itemMap
+        ]);
+        return getItems;
+    }
+    return [
+        {
+            Provider: CollectionProvider,
+            Slot: CollectionSlot,
+            ItemSlot: CollectionItemSlot
+        },
+        useCollection,
+        createCollectionScope
+    ];
+}
+
+function $fe963b355347cc68$export$3e6543de14f8614f(initialState, machine) {
+    return React.useReducer((state, event)=>{
+        const nextState = machine[state][event];
+        return nextState !== null && nextState !== void 0 ? nextState : state;
+    }, initialState);
+}
+
+
+const $921a889cee6df7e8$export$99c2b779aa4e8b8b = (props)=>{
+    const { present: present , children: children  } = props;
+    const presence = $921a889cee6df7e8$var$usePresence(present);
+    const child = typeof children === 'function' ? children({
+        present: presence.isPresent
+    }) : React.Children.only(children);
+    const ref = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(presence.ref, child.ref);
+    const forceMount = typeof children === 'function';
+    return forceMount || presence.isPresent ? /*#__PURE__*/ React.cloneElement(child, {
+        ref: ref
+    }) : null;
+};
+$921a889cee6df7e8$export$99c2b779aa4e8b8b.displayName = 'Presence';
+/* -------------------------------------------------------------------------------------------------
+ * usePresence
+ * -----------------------------------------------------------------------------------------------*/ function $921a889cee6df7e8$var$usePresence(present) {
+    const [node1, setNode] = React.useState();
+    const stylesRef = React.useRef({});
+    const prevPresentRef = React.useRef(present);
+    const prevAnimationNameRef = React.useRef('none');
+    const initialState = present ? 'mounted' : 'unmounted';
+    const [state, send] = $fe963b355347cc68$export$3e6543de14f8614f(initialState, {
+        mounted: {
+            UNMOUNT: 'unmounted',
+            ANIMATION_OUT: 'unmountSuspended'
+        },
+        unmountSuspended: {
+            MOUNT: 'mounted',
+            ANIMATION_END: 'unmounted'
+        },
+        unmounted: {
+            MOUNT: 'mounted'
+        }
+    });
+    React.useEffect(()=>{
+        const currentAnimationName = $921a889cee6df7e8$var$getAnimationName(stylesRef.current);
+        prevAnimationNameRef.current = state === 'mounted' ? currentAnimationName : 'none';
+    }, [
+        state
+    ]);
+    index.$9f79659886946c16$export$e5c5a5f917a5871c(()=>{
+        const styles = stylesRef.current;
+        const wasPresent = prevPresentRef.current;
+        const hasPresentChanged = wasPresent !== present;
+        if (hasPresentChanged) {
+            const prevAnimationName = prevAnimationNameRef.current;
+            const currentAnimationName = $921a889cee6df7e8$var$getAnimationName(styles);
+            if (present) send('MOUNT');
+            else if (currentAnimationName === 'none' || (styles === null || styles === void 0 ? void 0 : styles.display) === 'none') // If there is no exit animation or the element is hidden, animations won't run
+            // so we unmount instantly
+            send('UNMOUNT');
+            else {
+                /**
+         * When `present` changes to `false`, we check changes to animation-name to
+         * determine whether an animation has started. We chose this approach (reading
+         * computed styles) because there is no `animationrun` event and `animationstart`
+         * fires after `animation-delay` has expired which would be too late.
+         */ const isAnimating = prevAnimationName !== currentAnimationName;
+                if (wasPresent && isAnimating) send('ANIMATION_OUT');
+                else send('UNMOUNT');
+            }
+            prevPresentRef.current = present;
+        }
+    }, [
+        present,
+        send
+    ]);
+    index.$9f79659886946c16$export$e5c5a5f917a5871c(()=>{
+        if (node1) {
+            /**
+       * Triggering an ANIMATION_OUT during an ANIMATION_IN will fire an `animationcancel`
+       * event for ANIMATION_IN after we have entered `unmountSuspended` state. So, we
+       * make sure we only trigger ANIMATION_END for the currently active animation.
+       */ const handleAnimationEnd = (event)=>{
+                const currentAnimationName = $921a889cee6df7e8$var$getAnimationName(stylesRef.current);
+                const isCurrentAnimation = currentAnimationName.includes(event.animationName);
+                if (event.target === node1 && isCurrentAnimation) // With React 18 concurrency this update is applied
+                // a frame after the animation ends, creating a flash of visible content.
+                // By manually flushing we ensure they sync within a frame, removing the flash.
+                ReactDOM.flushSync(()=>send('ANIMATION_END')
+                );
+            };
+            const handleAnimationStart = (event)=>{
+                if (event.target === node1) // if animation occurred, store its name as the previous animation.
+                prevAnimationNameRef.current = $921a889cee6df7e8$var$getAnimationName(stylesRef.current);
+            };
+            node1.addEventListener('animationstart', handleAnimationStart);
+            node1.addEventListener('animationcancel', handleAnimationEnd);
+            node1.addEventListener('animationend', handleAnimationEnd);
+            return ()=>{
+                node1.removeEventListener('animationstart', handleAnimationStart);
+                node1.removeEventListener('animationcancel', handleAnimationEnd);
+                node1.removeEventListener('animationend', handleAnimationEnd);
+            };
+        } else // Transition to the unmounted state if the node is removed prematurely.
+        // We avoid doing so during cleanup as the node may change but still exist.
+        send('ANIMATION_END');
+    }, [
+        node1,
+        send
+    ]);
+    return {
+        isPresent: [
+            'mounted',
+            'unmountSuspended'
+        ].includes(state),
+        ref: React.useCallback((node)=>{
+            if (node) stylesRef.current = getComputedStyle(node);
+            setNode(node);
+        }, [])
+    };
+}
+/* -----------------------------------------------------------------------------------------------*/ function $921a889cee6df7e8$var$getAnimationName(styles) {
+    return (styles === null || styles === void 0 ? void 0 : styles.animationName) || 'none';
+}
+
+exports.$921a889cee6df7e8$export$99c2b779aa4e8b8b = $921a889cee6df7e8$export$99c2b779aa4e8b8b;
+exports.$e02a7d9cb1dc128c$export$c74125a8e3af6bb2 = $e02a7d9cb1dc128c$export$c74125a8e3af6bb2;