@primer/styled-react 0.0.0-20260325190039 → 0.0.0-20260325221512

package/dist/_virtual/_commonjsHelpers.js

@@ -0,0 +1,5 @@
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export { getDefaultExportFromCjs };

package/dist/_virtual/cjs.js

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs } from './_commonjsHelpers.js';
+import { __require as requireCjs } from '../node_modules/deepmerge/dist/cjs.js';
+
+var cjsExports = requireCjs();
+var deepmerge = /*@__PURE__*/getDefaultExportFromCjs(cjsExports);
+
+export { deepmerge as default };

package/dist/_virtual/focus-visible.js

@@ -0,0 +1,3 @@
+import { __require as requireFocusVisible } from '../node_modules/focus-visible/dist/focus-visible.js';
+
+requireFocusVisible();

package/dist/_virtual/focus-visible2.js

@@ -0,0 +1,3 @@
+var focusVisible = {exports: {}};
+
+export { focusVisible as __module };

package/dist/components.json

@@ -2,7 +2,6 @@
   "components": [
     "ActionList",
     "ActionMenu",
-    "Avatar",
     "BaseStyles",
     "Box",
     "Breadcrumb",
@@ -26,7 +25,6 @@
     "Table",
     "TabNav",
     "Text",
-    "Textarea",
     "TextInput",
     "ThemeProvider",
     "Timeline",
@@ -45,7 +43,6 @@
     "ActionListProps",
     "ActionListTrailingActionProps",
     "ActionListTrailingVisualProps",
-    "AvatarProps",
     "BaseStylesProps",
     "BetterSystemStyleObject",
     "BoxProps",
@@ -82,7 +79,6 @@
     "TableTitleProps",
     "TabNavLinkProps",
     "TabNavProps",
-    "TextareaProps",
     "TextInputActionProps",
     "TextInputProps",
     "TextProps",

package/dist/node_modules/clsx/dist/clsx.js

@@ -0,0 +1,3 @@
+function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}
+
+export { clsx };

package/dist/node_modules/deepmerge/dist/cjs.js

@@ -0,0 +1,142 @@
+var cjs;
+var hasRequiredCjs;
+
+function requireCjs () {
+	if (hasRequiredCjs) return cjs;
+	hasRequiredCjs = 1;
+
+	var isMergeableObject = function isMergeableObject(value) {
+		return isNonNullObject(value)
+			&& !isSpecial(value)
+	};
+
+	function isNonNullObject(value) {
+		return !!value && typeof value === 'object'
+	}
+
+	function isSpecial(value) {
+		var stringValue = Object.prototype.toString.call(value);
+
+		return stringValue === '[object RegExp]'
+			|| stringValue === '[object Date]'
+			|| isReactElement(value)
+	}
+
+	// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
+	var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
+	var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
+
+	function isReactElement(value) {
+		return value.$$typeof === REACT_ELEMENT_TYPE
+	}
+
+	function emptyTarget(val) {
+		return Array.isArray(val) ? [] : {}
+	}
+
+	function cloneUnlessOtherwiseSpecified(value, options) {
+		return (options.clone !== false && options.isMergeableObject(value))
+			? deepmerge(emptyTarget(value), value, options)
+			: value
+	}
+
+	function defaultArrayMerge(target, source, options) {
+		return target.concat(source).map(function(element) {
+			return cloneUnlessOtherwiseSpecified(element, options)
+		})
+	}
+
+	function getMergeFunction(key, options) {
+		if (!options.customMerge) {
+			return deepmerge
+		}
+		var customMerge = options.customMerge(key);
+		return typeof customMerge === 'function' ? customMerge : deepmerge
+	}
+
+	function getEnumerableOwnPropertySymbols(target) {
+		return Object.getOwnPropertySymbols
+			? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+				return Object.propertyIsEnumerable.call(target, symbol)
+			})
+			: []
+	}
+
+	function getKeys(target) {
+		return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
+	}
+
+	function propertyIsOnObject(object, property) {
+		try {
+			return property in object
+		} catch(_) {
+			return false
+		}
+	}
+
+	// Protects from prototype poisoning and unexpected merging up the prototype chain.
+	function propertyIsUnsafe(target, key) {
+		return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
+			&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
+				&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
+	}
+
+	function mergeObject(target, source, options) {
+		var destination = {};
+		if (options.isMergeableObject(target)) {
+			getKeys(target).forEach(function(key) {
+				destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+			});
+		}
+		getKeys(source).forEach(function(key) {
+			if (propertyIsUnsafe(target, key)) {
+				return
+			}
+
+			if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+				destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+			} else {
+				destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+			}
+		});
+		return destination
+	}
+
+	function deepmerge(target, source, options) {
+		options = options || {};
+		options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+		options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+		// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
+		// implementations can use it. The caller may not replace it.
+		options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+
+		var sourceIsArray = Array.isArray(source);
+		var targetIsArray = Array.isArray(target);
+		var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+
+		if (!sourceAndTargetTypesMatch) {
+			return cloneUnlessOtherwiseSpecified(source, options)
+		} else if (sourceIsArray) {
+			return options.arrayMerge(target, source, options)
+		} else {
+			return mergeObject(target, source, options)
+		}
+	}
+
+	deepmerge.all = function deepmergeAll(array, options) {
+		if (!Array.isArray(array)) {
+			throw new Error('first argument should be an array')
+		}
+
+		return array.reduce(function(prev, next) {
+			return deepmerge(prev, next, options)
+		}, {})
+	};
+
+	var deepmerge_1 = deepmerge;
+
+	cjs = deepmerge_1;
+	return cjs;
+}
+
+export { requireCjs as __require };

package/dist/node_modules/focus-visible/dist/focus-visible.js

@@ -0,0 +1,324 @@
+import { __module as focusVisible$1 } from '../../../_virtual/focus-visible2.js';
+
+var focusVisible = focusVisible$1.exports;
+
+var hasRequiredFocusVisible;
+
+function requireFocusVisible () {
+	if (hasRequiredFocusVisible) return focusVisible$1.exports;
+	hasRequiredFocusVisible = 1;
+	(function (module, exports$1) {
+		(function (global, factory) {
+		  factory() ;
+		}(focusVisible, (function () {
+		  /**
+		   * Applies the :focus-visible polyfill at the given scope.
+		   * A scope in this case is either the top-level Document or a Shadow Root.
+		   *
+		   * @param {(Document|ShadowRoot)} scope
+		   * @see https://github.com/WICG/focus-visible
+		   */
+		  function applyFocusVisiblePolyfill(scope) {
+		    var hadKeyboardEvent = true;
+		    var hadFocusVisibleRecently = false;
+		    var hadFocusVisibleRecentlyTimeout = null;
+
+		    var inputTypesAllowlist = {
+		      text: true,
+		      search: true,
+		      url: true,
+		      tel: true,
+		      email: true,
+		      password: true,
+		      number: true,
+		      date: true,
+		      month: true,
+		      week: true,
+		      time: true,
+		      datetime: true,
+		      'datetime-local': true
+		    };
+
+		    /**
+		     * Helper function for legacy browsers and iframes which sometimes focus
+		     * elements like document, body, and non-interactive SVG.
+		     * @param {Element} el
+		     */
+		    function isValidFocusTarget(el) {
+		      if (
+		        el &&
+		        el !== document &&
+		        el.nodeName !== 'HTML' &&
+		        el.nodeName !== 'BODY' &&
+		        'classList' in el &&
+		        'contains' in el.classList
+		      ) {
+		        return true;
+		      }
+		      return false;
+		    }
+
+		    /**
+		     * Computes whether the given element should automatically trigger the
+		     * `focus-visible` class being added, i.e. whether it should always match
+		     * `:focus-visible` when focused.
+		     * @param {Element} el
+		     * @return {boolean}
+		     */
+		    function focusTriggersKeyboardModality(el) {
+		      var type = el.type;
+		      var tagName = el.tagName;
+
+		      if (tagName === 'INPUT' && inputTypesAllowlist[type] && !el.readOnly) {
+		        return true;
+		      }
+
+		      if (tagName === 'TEXTAREA' && !el.readOnly) {
+		        return true;
+		      }
+
+		      if (el.isContentEditable) {
+		        return true;
+		      }
+
+		      return false;
+		    }
+
+		    /**
+		     * Add the `focus-visible` class to the given element if it was not added by
+		     * the author.
+		     * @param {Element} el
+		     */
+		    function addFocusVisibleClass(el) {
+		      if (el.classList.contains('focus-visible')) {
+		        return;
+		      }
+		      el.classList.add('focus-visible');
+		      el.setAttribute('data-focus-visible-added', '');
+		    }
+
+		    /**
+		     * Remove the `focus-visible` class from the given element if it was not
+		     * originally added by the author.
+		     * @param {Element} el
+		     */
+		    function removeFocusVisibleClass(el) {
+		      if (!el.hasAttribute('data-focus-visible-added')) {
+		        return;
+		      }
+		      el.classList.remove('focus-visible');
+		      el.removeAttribute('data-focus-visible-added');
+		    }
+
+		    /**
+		     * If the most recent user interaction was via the keyboard;
+		     * and the key press did not include a meta, alt/option, or control key;
+		     * then the modality is keyboard. Otherwise, the modality is not keyboard.
+		     * Apply `focus-visible` to any current active element and keep track
+		     * of our keyboard modality state with `hadKeyboardEvent`.
+		     * @param {KeyboardEvent} e
+		     */
+		    function onKeyDown(e) {
+		      if (e.metaKey || e.altKey || e.ctrlKey) {
+		        return;
+		      }
+
+		      if (isValidFocusTarget(scope.activeElement)) {
+		        addFocusVisibleClass(scope.activeElement);
+		      }
+
+		      hadKeyboardEvent = true;
+		    }
+
+		    /**
+		     * If at any point a user clicks with a pointing device, ensure that we change
+		     * the modality away from keyboard.
+		     * This avoids the situation where a user presses a key on an already focused
+		     * element, and then clicks on a different element, focusing it with a
+		     * pointing device, while we still think we're in keyboard modality.
+		     * @param {Event} e
+		     */
+		    function onPointerDown(e) {
+		      hadKeyboardEvent = false;
+		    }
+
+		    /**
+		     * On `focus`, add the `focus-visible` class to the target if:
+		     * - the target received focus as a result of keyboard navigation, or
+		     * - the event target is an element that will likely require interaction
+		     *   via the keyboard (e.g. a text box)
+		     * @param {Event} e
+		     */
+		    function onFocus(e) {
+		      // Prevent IE from focusing the document or HTML element.
+		      if (!isValidFocusTarget(e.target)) {
+		        return;
+		      }
+
+		      if (hadKeyboardEvent || focusTriggersKeyboardModality(e.target)) {
+		        addFocusVisibleClass(e.target);
+		      }
+		    }
+
+		    /**
+		     * On `blur`, remove the `focus-visible` class from the target.
+		     * @param {Event} e
+		     */
+		    function onBlur(e) {
+		      if (!isValidFocusTarget(e.target)) {
+		        return;
+		      }
+
+		      if (
+		        e.target.classList.contains('focus-visible') ||
+		        e.target.hasAttribute('data-focus-visible-added')
+		      ) {
+		        // To detect a tab/window switch, we look for a blur event followed
+		        // rapidly by a visibility change.
+		        // If we don't see a visibility change within 100ms, it's probably a
+		        // regular focus change.
+		        hadFocusVisibleRecently = true;
+		        window.clearTimeout(hadFocusVisibleRecentlyTimeout);
+		        hadFocusVisibleRecentlyTimeout = window.setTimeout(function() {
+		          hadFocusVisibleRecently = false;
+		        }, 100);
+		        removeFocusVisibleClass(e.target);
+		      }
+		    }
+
+		    /**
+		     * If the user changes tabs, keep track of whether or not the previously
+		     * focused element had .focus-visible.
+		     * @param {Event} e
+		     */
+		    function onVisibilityChange(e) {
+		      if (document.visibilityState === 'hidden') {
+		        // If the tab becomes active again, the browser will handle calling focus
+		        // on the element (Safari actually calls it twice).
+		        // If this tab change caused a blur on an element with focus-visible,
+		        // re-apply the class when the user switches back to the tab.
+		        if (hadFocusVisibleRecently) {
+		          hadKeyboardEvent = true;
+		        }
+		        addInitialPointerMoveListeners();
+		      }
+		    }
+
+		    /**
+		     * Add a group of listeners to detect usage of any pointing devices.
+		     * These listeners will be added when the polyfill first loads, and anytime
+		     * the window is blurred, so that they are active when the window regains
+		     * focus.
+		     */
+		    function addInitialPointerMoveListeners() {
+		      document.addEventListener('mousemove', onInitialPointerMove);
+		      document.addEventListener('mousedown', onInitialPointerMove);
+		      document.addEventListener('mouseup', onInitialPointerMove);
+		      document.addEventListener('pointermove', onInitialPointerMove);
+		      document.addEventListener('pointerdown', onInitialPointerMove);
+		      document.addEventListener('pointerup', onInitialPointerMove);
+		      document.addEventListener('touchmove', onInitialPointerMove);
+		      document.addEventListener('touchstart', onInitialPointerMove);
+		      document.addEventListener('touchend', onInitialPointerMove);
+		    }
+
+		    function removeInitialPointerMoveListeners() {
+		      document.removeEventListener('mousemove', onInitialPointerMove);
+		      document.removeEventListener('mousedown', onInitialPointerMove);
+		      document.removeEventListener('mouseup', onInitialPointerMove);
+		      document.removeEventListener('pointermove', onInitialPointerMove);
+		      document.removeEventListener('pointerdown', onInitialPointerMove);
+		      document.removeEventListener('pointerup', onInitialPointerMove);
+		      document.removeEventListener('touchmove', onInitialPointerMove);
+		      document.removeEventListener('touchstart', onInitialPointerMove);
+		      document.removeEventListener('touchend', onInitialPointerMove);
+		    }
+
+		    /**
+		     * When the polfyill first loads, assume the user is in keyboard modality.
+		     * If any event is received from a pointing device (e.g. mouse, pointer,
+		     * touch), turn off keyboard modality.
+		     * This accounts for situations where focus enters the page from the URL bar.
+		     * @param {Event} e
+		     */
+		    function onInitialPointerMove(e) {
+		      // Work around a Safari quirk that fires a mousemove on <html> whenever the
+		      // window blurs, even if you're tabbing out of the page. ¯\_(ツ)_/¯
+		      if (e.target.nodeName && e.target.nodeName.toLowerCase() === 'html') {
+		        return;
+		      }
+
+		      hadKeyboardEvent = false;
+		      removeInitialPointerMoveListeners();
+		    }
+
+		    // For some kinds of state, we are interested in changes at the global scope
+		    // only. For example, global pointer input, global key presses and global
+		    // visibility change should affect the state at every scope:
+		    document.addEventListener('keydown', onKeyDown, true);
+		    document.addEventListener('mousedown', onPointerDown, true);
+		    document.addEventListener('pointerdown', onPointerDown, true);
+		    document.addEventListener('touchstart', onPointerDown, true);
+		    document.addEventListener('visibilitychange', onVisibilityChange, true);
+
+		    addInitialPointerMoveListeners();
+
+		    // For focus and blur, we specifically care about state changes in the local
+		    // scope. This is because focus / blur events that originate from within a
+		    // shadow root are not re-dispatched from the host element if it was already
+		    // the active element in its own scope:
+		    scope.addEventListener('focus', onFocus, true);
+		    scope.addEventListener('blur', onBlur, true);
+
+		    // We detect that a node is a ShadowRoot by ensuring that it is a
+		    // DocumentFragment and also has a host property. This check covers native
+		    // implementation and polyfill implementation transparently. If we only cared
+		    // about the native implementation, we could just check if the scope was
+		    // an instance of a ShadowRoot.
+		    if (scope.nodeType === Node.DOCUMENT_FRAGMENT_NODE && scope.host) {
+		      // Since a ShadowRoot is a special kind of DocumentFragment, it does not
+		      // have a root element to add a class to. So, we add this attribute to the
+		      // host element instead:
+		      scope.host.setAttribute('data-js-focus-visible', '');
+		    } else if (scope.nodeType === Node.DOCUMENT_NODE) {
+		      document.documentElement.classList.add('js-focus-visible');
+		      document.documentElement.setAttribute('data-js-focus-visible', '');
+		    }
+		  }
+
+		  // It is important to wrap all references to global window and document in
+		  // these checks to support server-side rendering use cases
+		  // @see https://github.com/WICG/focus-visible/issues/199
+		  if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+		    // Make the polyfill helper globally available. This can be used as a signal
+		    // to interested libraries that wish to coordinate with the polyfill for e.g.,
+		    // applying the polyfill to a shadow root:
+		    window.applyFocusVisiblePolyfill = applyFocusVisiblePolyfill;
+
+		    // Notify interested libraries of the polyfill's presence, in case the
+		    // polyfill was loaded lazily:
+		    var event;
+
+		    try {
+		      event = new CustomEvent('focus-visible-polyfill-ready');
+		    } catch (error) {
+		      // IE11 does not support using CustomEvent as a constructor directly:
+		      event = document.createEvent('CustomEvent');
+		      event.initCustomEvent('focus-visible-polyfill-ready', false, false, {});
+		    }
+
+		    window.dispatchEvent(event);
+		  }
+
+		  if (typeof document !== 'undefined') {
+		    // Apply the polyfill to the global document, so that no JavaScript
+		    // coordination is required to use the polyfill in the top-level document:
+		    applyFocusVisiblePolyfill(document);
+		  }
+
+		}))); 
+	} ());
+	return focusVisible$1.exports;
+}
+
+export { requireFocusVisible as __require };

package/dist/{components → packages/styled-react/src/components}/BaseStyles.js

@@ -1,6 +1,6 @@
-import { clsx } from 'clsx';
+import { clsx } from '../../../../node_modules/clsx/dist/clsx.js';
 import { useTheme } from './ThemeProvider.js';
-import 'focus-visible';
+import '../../../../_virtual/focus-visible.js';
 import { createGlobalStyle } from 'styled-components';
 import { jsxs, jsx } from 'react/jsx-runtime';