@algolia/satellite 1.0.0-beta.16 → 1.0.0-beta.160

package/{utils → cjs/utils}/uniqBy.js

@@ -3,23 +3,19 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.uniqBy = uniqBy;
 exports["default"] = void 0;
-
+exports.uniqBy = uniqBy;
 function uniqBy(arr, identity) {
   if (!arr) return arr;
   var memo = [];
   return arr.filter(function (item) {
     var id = identity(item);
-
     if (memo.includes(id)) {
       return false;
     }
-
     memo.push(id);
     return true;
   });
 }
-
 var _default = uniqBy;
 exports["default"] = _default;

package/{utils → cjs/utils}/uniqueId.js

@@ -3,15 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.uniqueId = uniqueId;
 exports["default"] = void 0;
+exports.uniqueId = uniqueId;
 var counters = {};
-
 function uniqueId() {
   var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "id";
   counters[prefix] = counters[prefix] === undefined ? 0 : counters[prefix] + 1;
   return prefix + counters[prefix];
 }
-
 var _default = uniqueId;
 exports["default"] = _default;

package/cjs/utils/useForwardedRef.d.ts

@@ -0,0 +1,3 @@
+import type { MutableRefObject, Ref } from "react";
+declare function useForwardedRef<T>(externalRef: Ref<T | null> | undefined): [(instance: T | null) => void, MutableRefObject<T | null>];
+export default useForwardedRef;

package/cjs/utils/useForwardedRef.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _react = require("react");
+function useForwardedRef(externalRef) {
+  var ref = (0, _react.useRef)(externalRef && (0, _typeof2["default"])(externalRef) === "object" ? externalRef.current : null);
+  var refCallback = (0, _react.useCallback)(function (value) {
+    ref.current = value;
+    if (!externalRef) {
+      return;
+    } else if (typeof externalRef === "function") {
+      externalRef(value);
+    } else {
+      externalRef.current = value;
+    }
+  }, [externalRef]);
+  return [refCallback, ref];
+}
+var _default = useForwardedRef;
+exports["default"] = _default;

package/cjs/utils/useLinkProps.d.ts

@@ -0,0 +1,7 @@
+import type { AnchorHTMLAttributes } from "react";
+export declare type UseLinkPropsArgs = Pick<AnchorHTMLAttributes<HTMLAnchorElement>, "href" | "onClick" | "target" | "rel" | "role" | "tabIndex"> & {
+    disabled?: boolean;
+};
+export declare type UseLinkProps = Pick<AnchorHTMLAttributes<HTMLAnchorElement>, "href" | "onClick" | "target" | "rel" | "role" | "tabIndex" | "aria-disabled">;
+export declare const useLinkProps: (props: UseLinkPropsArgs) => UseLinkProps;
+export default useLinkProps;

package/cjs/utils/useLinkProps.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useLinkProps = exports["default"] = void 0;
+var _react = require("react");
+var _SatelliteContext = require("../Satellite/SatelliteContext");
+var _parseUrl = _interopRequireDefault(require("./parseUrl"));
+var useLinkProps = function useLinkProps(props) {
+  var _props$target, _props$rel;
+  var _useSatelliteContext = (0, _SatelliteContext.useSatelliteContext)(),
+    router = _useSatelliteContext.router;
+  var onClick = function onClick(evt) {
+    if (props.onClick) {
+      props.onClick(evt);
+    }
+    if (!props.href) {
+      return;
+    }
+    var isLeftClick = evt.button === 0;
+    var isModifierKeyPressed = Boolean(evt.metaKey || evt.altKey || evt.ctrlKey || evt.shiftKey);
+    var hasTarget = Boolean(evt.currentTarget.target);
+    if (isLeftClick && !isModifierKeyPressed && !hasTarget && !evt.defaultPrevented && evt.currentTarget.href) {
+      evt.preventDefault();
+      router.push({
+        url: evt.currentTarget.href
+      });
+    }
+  };
+  var href = router.transformHref(props.href || "");
+  var parsedLocation = (0, _react.useMemo)(function () {
+    return (0, _parseUrl["default"])(href);
+  }, [href]);
+  var isExternal = router.isExternalLocation(parsedLocation);
+  var target = (_props$target = props.target) !== null && _props$target !== void 0 ? _props$target : router.shouldOpenInNewTab(parsedLocation) ? "_blank" : undefined;
+  var rel = (_props$rel = props.rel) !== null && _props$rel !== void 0 ? _props$rel : isExternal ? "noopener noreferrer" : undefined;
+  return props.disabled ? {
+    role: "link",
+    target: target,
+    tabIndex: -1,
+    "aria-disabled": true
+  } : {
+    target: target,
+    href: href,
+    rel: rel,
+    onClick: onClick,
+    role: props.role,
+    tabIndex: props.tabIndex
+  };
+};
+exports.useLinkProps = useLinkProps;
+var _default = useLinkProps;
+exports["default"] = _default;

package/cjs/utils/useTriggerInputChange.d.ts

@@ -0,0 +1,8 @@
+import type { MutableRefObject } from "react";
+declare type InputValue = JSX.IntrinsicElements["input"]["value"];
+/**
+ * Trigger a native input change event.
+ * See https://stackoverflow.com/questions/23892547/what-is-the-best-way-to-trigger-onchange-event-in-react-js
+ */
+declare const useTriggerInputChange: (inputRef: MutableRefObject<HTMLInputElement | null>) => (value: InputValue) => void;
+export default useTriggerInputChange;

package/cjs/utils/useTriggerInputChange.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = require("react");
+/**
+ * Trigger a native input change event.
+ * See https://stackoverflow.com/questions/23892547/what-is-the-best-way-to-trigger-onchange-event-in-react-js
+ */
+var useTriggerInputChange = function useTriggerInputChange(inputRef) {
+  var triggerInputChange = (0, _react.useCallback)(function (value) {
+    var input = inputRef.current;
+    if (!input) return;
+
+    // @ts-ignore
+    var nativeInputValueSetter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value").set;
+    var ev2 = new Event("input", {
+      bubbles: true
+    });
+    nativeInputValueSetter.call(input, value);
+    input.dispatchEvent(ev2);
+  }, [inputRef]);
+  return triggerInputChange;
+};
+var _default = useTriggerInputChange;
+exports["default"] = _default;

package/esm/AnnouncementBadge/AnnouncementBadge.d.ts

@@ -0,0 +1,21 @@
+import type { FunctionComponent, HTMLAttributes } from "react";
+export declare type AnnouncementBadgeSizes = "default" | "small";
+export declare type AnnouncementBadgeTexts = "new" | "beta" | "internal" | "pilot";
+export declare type AnnouncementBadgeLocale = {
+    [key in AnnouncementBadgeTexts]?: string;
+};
+export interface AnnouncementBadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    /** @default "default" */
+    size?: AnnouncementBadgeSizes;
+    /**
+     * Define which text to display in the `AnnouncementBadge`
+     * @default "new"
+     */
+    text?: AnnouncementBadgeTexts;
+    /** @default "accent" */
+    variant?: "accent" | "red";
+    locale?: AnnouncementBadgeLocale;
+    children?: never;
+}
+export declare const AnnouncementBadge: FunctionComponent<AnnouncementBadgeProps>;
+export default AnnouncementBadge;

package/esm/AnnouncementBadge/AnnouncementBadge.js

@@ -0,0 +1,40 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+var _excluded = ["size", "text", "variant", "className", "locale"];
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5;
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import cx from "clsx";
+import { useLocale } from "../Satellite";
+import stl from "../styles/helpers/satellitePrefixer";
+import { jsx as _jsx } from "react/jsx-runtime";
+var DEFAULT_LOCALE = {
+  beta: "beta",
+  internal: "internal",
+  "new": "new",
+  pilot: "pilot"
+};
+var DEFAULT_CLASSNAME = stl(_templateObject || (_templateObject = _taggedTemplateLiteral(["capitalize inline-block rounded-full text-white select-none"])));
+var SIZE_CLASSNAMES = {
+  "default": stl(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["display-body h-6 leading-md px-2"]))),
+  small: stl(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["display-caption px-1"])))
+};
+export var AnnouncementBadge = function AnnouncementBadge(_ref) {
+  var _ref$size = _ref.size,
+    size = _ref$size === void 0 ? "default" : _ref$size,
+    _ref$text = _ref.text,
+    text = _ref$text === void 0 ? "new" : _ref$text,
+    variantProp = _ref.variant,
+    className = _ref.className,
+    propsLocale = _ref.locale,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var contextLocale = useLocale("announcementBadge");
+  var locale = _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_LOCALE), contextLocale), propsLocale);
+  var variant = typeof variantProp === "string" ? variantProp : text === "internal" ? "red" : "accent";
+  return /*#__PURE__*/_jsx("span", _objectSpread(_objectSpread({}, props), {}, {
+    className: cx(DEFAULT_CLASSNAME, variant === "red" ? stl(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["bg-red-600"]))) : stl(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["bg-accent-600"]))), SIZE_CLASSNAMES[size], className),
+    children: locale[text]
+  }));
+};
+export default AnnouncementBadge;

package/esm/AnnouncementBadge/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./AnnouncementBadge";
+export { default } from "./AnnouncementBadge";

package/esm/AnnouncementBadge/index.js

@@ -0,0 +1,2 @@
+export * from "./AnnouncementBadge";
+export { default } from "./AnnouncementBadge";

package/esm/AutoComplete/AutoComplete.d.ts

@@ -0,0 +1,66 @@
+import type { A11yStatusMessageOptions, ControllerStateAndHelpers } from "downshift";
+import { Component } from "react";
+import type { ChangeEvent, FocusEvent, KeyboardEvent, MouseEvent } from "react";
+import { FieldState } from "../Field/FieldStateContext";
+import type { AutoCompleteLocale, AutoCompleteProps, Option, OptionItemProps } from "./types";
+interface State {
+    inputFocused: boolean;
+    inputValue: string;
+    inputWidth?: number;
+    showAllResults: boolean;
+}
+declare type DefaultOptionProps = OptionItemProps & {
+    optionItemPrefix?: AutoCompleteLocale["optionItemPrefix"];
+};
+/**
+ * Autocomplete is a search-as-you-type function that matches what a person types, usually the beginning of a word, or a prefix, with a word list. Not to be confused with auto-suggestion that predicts the end of a query.
+ *
+ * Use this component when the user needs to search through a long list of results.
+ *
+ * ## Menu Size Variations
+ * - **Medium (default)**: the standard dropdown menu height for most use cases
+ * - **Large**: when numerous results should be displayed in the dropdown to ease selection
+ *
+ * ## Best practices
+ *
+ * - Provide an empty state if there is no result
+ * - Highlight letters in results matching the query
+ * - Provide matching results quickly
+ * - Style different data
+ */
+export declare class AutoComplete<T extends Option = Option> extends Component<AutoCompleteProps<T>, State> {
+    static contextType: import("react").Context<import("../Satellite").SatelliteContextType>;
+    static defaultProps: {
+        clearable: boolean;
+        creatable: boolean;
+        multiple: boolean;
+        maxResults: number;
+        createFromInputValue: <T_1 extends Option = Option>(options: T_1[] | undefined, inputValue: string) => Option[];
+        options: never[];
+        separatorKeys: never[];
+        optionItemComponent: ({ optionItemPrefix, ...props }: DefaultOptionProps) => JSX.Element;
+        noWrap: boolean;
+    };
+    state: State;
+    inputContainerRef: HTMLDivElement | null;
+    inputRef: HTMLInputElement | null;
+    menuWrapperRef: HTMLDivElement | null;
+    componentDidUpdate(prevProps: AutoCompleteProps<T>): void;
+    handleClearClick: () => void;
+    handleFakeInputClick: () => void | null;
+    handleInputBlur: (state: ControllerStateAndHelpers<T | Option>) => (evt: FocusEvent<HTMLInputElement>) => void;
+    handleInputChange: (evt: ChangeEvent<HTMLInputElement>) => void;
+    handleInputContainerRefUpdate: (el: HTMLDivElement | null) => void;
+    updateInputWidth: () => void;
+    handleKeyDown: (state: ControllerStateAndHelpers<T | Option>) => (evt: KeyboardEvent<any>) => void;
+    handleChange: (option: T) => void;
+    handleShowAllResults: (evt: MouseEvent<HTMLButtonElement>) => void;
+    removeValue: (removedOption: T) => void;
+    getA11yStatusMessage: (options: A11yStatusMessageOptions<Option>) => any;
+    renderInput: (autocompleteHelpers: ControllerStateAndHelpers<T | Option>, fieldState: FieldState) => JSX.Element;
+    renderMenu: (results: T[], autocompleteHelpers: ControllerStateAndHelpers<T | Option>) => JSX.Element;
+    renderSelect: (autocompleteHelpers: ControllerStateAndHelpers<T | Option>, fieldState: FieldState) => JSX.Element;
+    private get locale();
+    render(): JSX.Element;
+}
+export default AutoComplete;