@koine/react 1.0.10 → 1.0.11

package/node/Autocomplete/AutocompleteMui.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Autocomplete = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const AutocompleteUnstyled_1 = require("@mui/base/AutocompleteUnstyled");
+const utils_1 = require("@koine/utils");
+const helpers_1 = require("../Forms/helpers");
+const helpers_2 = require("./helpers");
+const components_1 = require("./components");
+const styles_1 = require("../Forms/styles");
+/**
+ * Autocomplete/autocomplete component based on [`@mui useAutocomplete hook`](https://mui.com/components/autocomplete/#useautocomplete).
+ *
+ * This component is design to work out of the box with [`react-hook-form`](https://react-hook-form.com/)
+ * and [`yup`](https://github.com/jquense/yup) alongside our custom `Field`
+ * component.
+ *
+ * After a lot of tests and attempts with `downshift` and `@reach` this proved
+ * the best headless hook, small in size and behaving correctly in all scenarios.
+ * `downshift` had in fact problems treating the initial `defaultValue` which
+ * here is elegantly managed by the `isOptionEqualToValue` option passed into
+ * the `useAutocomplete` hook.
+ *
+ *
+ * Validation with `yup` and `react-hook-form` example:
+ *
+ * ```ts
+ * const schema = object({
+ *   // the value must be an array with at least one non-empty string
+ *   test1: array(string().required()).required().min(1),
+ *   // the value must be an array of strings or an empty array
+ *   test2: array(string().required()).required(),
+ * }).required();
+ * ```
+ */
+// export const Autocomplete = <TOption, TValue>forwardRef<
+//  HTMLInputElement,
+//  PropsWithChildren<AutocompleteProps<TOption, TValue>
+// >(function Autocomplete(
+//  {
+//    creatable,
+//    multiple,
+//    autoComplete,
+//    loadOptions,
+//    options: defaultOptions = [],
+//    defaultValue = [],
+//    label,
+//    register,
+//    setValue,
+//    // trigger,
+//    name,
+//    onChange,
+//    $ref,
+//    children,
+//    ...props
+//  },
+//  ref
+// ) {
+const Autocomplete = ({ creatable, multiple, autoComplete, loadOptions, options: defaultOptions = [], defaultValue, value: controlledValue, defaultInputValue, label, placeholder, register, setValue, 
+// trigger,
+name, onChange, $ref, children, ...props }) => {
+    const defaultOptionsMemo = (0, react_1.useMemo)(() => (0, helpers_1.normaliseOptions)(defaultOptions), [defaultOptions]);
+    const [options, setOptions] = (0, react_1.useState)(defaultOptionsMemo);
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const { getRootProps, getInputLabelProps, getInputProps, getTagProps, getListboxProps, getOptionProps, getPopupIndicatorProps, groupedOptions, value: stateValue, setAnchorEl, popupOpen, focused, } = (0, AutocompleteUnstyled_1.useAutocomplete)({
+        id: "Autocomplete",
+        multiple: multiple ? true : undefined,
+        freeSolo: creatable ? true : undefined,
+        // autoComplete: autoComplete ? true : undefined,
+        disableCloseOnSelect: true,
+        openOnFocus: true,
+        blurOnSelect: autoComplete && !multiple,
+        selectOnFocus: creatable,
+        // TODO: passing the defaultInputValue makes the input controlled, which is
+        // not what I want, so we probably need to handle the input default value
+        // ourselves
+        // inputValue: defaultInputValue,
+        // @ts-expect-error FIXME: how?
+        defaultValue,
+        // @ts-expect-error FIXME: how?
+        value: controlledValue,
+        // defaultValue: useMemo(
+        //   () => normaliseAutocompleteValue(defaultValue, multiple),
+        //   [defaultValue]
+        // ),
+        options: (0, react_1.useMemo)(() => (loadOptions ? options : defaultOptions), [loadOptions, options, defaultOptions]),
+        // update input change only if we are searching as you type, @see
+        // https://mui.com/components/autocomplete/#search-as-you-type
+        onInputChange: (0, react_1.useCallback)(async (_event, inputValue) => {
+            if (!loadOptions) {
+                return;
+            }
+            if (inputValue) {
+                setLoading(true);
+                try {
+                    const newOptions = await loadOptions(inputValue);
+                    setOptions(newOptions);
+                }
+                catch (e) {
+                    console.warn(e);
+                }
+                finally {
+                    setLoading(false);
+                }
+            }
+            else {
+                setOptions(options);
+                // TODO: clear like behaviour?
+                // triggerChange({ value: "", label: "" });
+            }
+        }, [loadOptions, options]),
+        // TODO: check if we need this, probably, and check how to structure the
+        // callback, here we get the actual input event
+        onChange: (event, newValue) => {
+            const value = (0, helpers_2.normaliseAutocompleteValue)(newValue, multiple);
+            // @ts-expect-error FIXME: how?
+            if (onChange)
+                onChange(newValue);
+            if (setValue)
+                setValue(name, value, { shouldValidate: true });
+            // triggerOnChange(onChange, name, value);
+        },
+        // support both freeSolo free text and full option structure
+        isOptionEqualToValue: (option, value) => {
+            const optValue = (0, utils_1.isString)(option) ? option : option.value;
+            const valValue = (0, utils_1.isString)(value) ? value : value.value;
+            return optValue === valValue;
+        },
+        getOptionLabel: (option) => {
+            // @ts-expect-error TODO: I don't get this error
+            return (0, utils_1.isString)(option) ? option : option.label || "";
+        },
+    });
+    const value = typeof controlledValue !== "undefined" ? controlledValue : stateValue;
+    const inputProps = () => {
+        const autocompleteProps = getInputProps();
+        // here we merge the mui's `useAutocomplete` props with the react-hook-form's
+        // `register` props
+        const registerProps = register
+            ? register(name, {
+                // @ts-expect-error FIXME: can't remember
+                ref: autocompleteProps.ref.current,
+                // this makes the validation works when a valid `defaultValue`
+                // is provided
+                value: (0, helpers_2.normaliseAutocompleteValue)(value, multiple),
+            })
+            : {};
+        return {
+            ...registerProps,
+            ...autocompleteProps,
+            // onChange: (event: FormEvent<HTMLInputElement>) => {
+            //   registerProps.onChange(event);
+            //   autocompleteProps?.onChange(event);
+            // },
+        };
+    };
+    // to focus the input on error this works too
+    // @see https://react-hook-form.com/faqs#question12 but probably it is
+    // better to do as now passing the input ref to the register options
+    // useEffect(() => {
+    //   if (errors[name]) {
+    //     inputProps.ref.current.focus();
+    //   }
+    // }, [errors, name, inputProps.ref]);
+    return ((0, jsx_runtime_1.jsxs)(components_1.AutocompleteRoot, { children: [label && ((0, jsx_runtime_1.jsx)(components_1.AutocompleteLabel, { ...getInputLabelProps(), children: label })), (0, jsx_runtime_1.jsxs)(components_1.AutocompleteWrap, { ...getRootProps(), "data-focus": focused, children: [(0, jsx_runtime_1.jsxs)(components_1.AutocompleteInner, { ref: setAnchorEl, children: [multiple &&
+                                value.map((valueItem, index) => {
+                                    const { onDelete, key, ...tagProps } = getTagProps({ index });
+                                    return ((0, jsx_runtime_1.jsxs)(components_1.AutocompleteItem, { ...tagProps, children: [(0, jsx_runtime_1.jsx)(components_1.AutocompleteItemLabel, { children: (0, utils_1.isString)(valueItem)
+                                                    ? valueItem
+                                                    : valueItem.Label || valueItem.label }), (0, jsx_runtime_1.jsx)(components_1.AutocompleteItemRemove, { onClick: onDelete, children: "\u2715" })] }, key));
+                                }), (0, jsx_runtime_1.jsx)(components_1.AutocompleteInput, { ...inputProps(), placeholder: placeholder })] }), !!options.length && ((0, jsx_runtime_1.jsx)(components_1.AutocompleteInputArrow, { ...getPopupIndicatorProps(), isOpen: popupOpen })), loading && (0, jsx_runtime_1.jsx)(styles_1.InputProgress, {})] }), groupedOptions.length ? ((0, jsx_runtime_1.jsx)(components_1.AutocompleteMenu, { ...getListboxProps(), children: groupedOptions.map((option, index) => ((0, jsx_runtime_1.jsx)(components_1.AutocompleteMenuItem, { ...getOptionProps({ option, index }), children: (0, utils_1.isString)(option) ? option : option.Label || option.label }, index))) })) : null, children] }));
+    // });
+};
+exports.Autocomplete = Autocomplete;

package/node/Autocomplete/AutocompleteReach.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Autocomplete = void 0;
+// TODO: remove, just use mui version...
+exports.Autocomplete = null;
+// import {
+//   forwardRef,
+//   useCallback,
+//   useState,
+//   ForwardedRef,
+//   ReactNode,
+//   ComponentPropsWithRef,
+//   CSSProperties,
+//   ChangeEventHandler,
+// } from "react";
+// import {
+//   Combobox,
+//   ComboboxInput,
+//   ComboboxPopover,
+//   ComboboxList,
+//   ComboboxOption,
+//   ComboboxOptionText,
+// } from "@reach/combobox";
+// import {
+//   AutocompleteRoot,
+//   AutocompleteInput,
+//   AutocompleteLabel,
+// } from "./components";
+// import type { Option } from "../types";
+// import { SetRequired } from "@koine/utils";
+// export type AutocompleteOption =
+//   | null
+//   | (Option & {
+//       key: string;
+//     });
+// export type AutocompleteProps = SetRequired<
+//   ComponentPropsWithRef<"input">,
+//   "onChange" | "name"
+// > & {
+//   onSelect?: (option?: AutocompleteOption) => any;
+//   options: AutocompleteOption[];
+//   loadOptions: (query?: string) => Promise<AutocompleteOption[]>;
+//   label?: string | ReactNode;
+//   className?: string;
+//   style?: CSSProperties;
+//   $ref: ForwardedRef<HTMLInputElement>;
+// };
+// export const Autocomplete = forwardRef<HTMLInputElement, AutocompleteProps>(
+//   function Autocomplete(
+//     {
+//       options = [],
+//       label,
+//       name,
+//       value,
+//       onChange,
+//       loadOptions,
+//       $ref,
+//       className,
+//       style,
+//       ...props
+//     },
+//     ref
+//   ) {
+//     const [items, setItems] = useState(options);
+//     const [loading, setLoading] = useState(false);
+//     const handleInputValueChange: ChangeEventHandler<HTMLInputElement> =
+//       useCallback(
+//         async (event) => {
+//           const inputValue = event.target.value;
+//           if (loadOptions) {
+//             setLoading(true);
+//             try {
+//               const newOptions = await loadOptions(inputValue);
+//               setItems(newOptions);
+//             } catch (e) {}
+//             setLoading(false);
+//           }
+//         },
+//         [loadOptions]
+//       );
+//     return (
+//       <AutocompleteRoot>
+//         {label && <AutocompleteLabel>{label}</AutocompleteLabel>}
+//         <Combobox aria-label="choose a fruit" openOnFocus={true}>
+//           <AutocompleteInput
+//             forwardedAs={ComboboxInput}
+//             ref={$ref}
+//             onChange={handleInputValueChange}
+//             selectOnClick={true}
+//             autocomplete={false}
+//           />
+//           {(!!items.length || loading) && (
+//             <ComboboxPopover>
+//               <ComboboxList persistSelection>
+//                 {items
+//                   // .filter(item => !inputValue || item.includes(inputValue))
+//                   .map(
+//                     (item, index) =>
+//                       item && (
+//                         <ComboboxOption
+//                           key={`${item.value}${index}`}
+//                           value={item.label}
+//                         >
+//                           <ComboboxOptionText />
+//                         </ComboboxOption>
+//                       )
+//                   )}
+//               </ComboboxList>
+//             </ComboboxPopover>
+//           )}
+//         </Combobox>
+//       </AutocompleteRoot>
+//     );
+//   }
+// );

package/node/Autocomplete/components.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutocompleteMenuItem = exports.AutocompleteMenu = exports.AutocompleteInputArrow = exports.AutocompleteInput = exports.AutocompleteInputWrap = exports.AutocompleteItemRemove = exports.AutocompleteItemLabel = exports.AutocompleteItem = exports.AutocompleteInner = exports.AutocompleteWrap = exports.AutocompleteLabel = exports.AutocompleteRoot = void 0;
+const tslib_1 = require("tslib");
+const styled_components_1 = tslib_1.__importDefault(require("styled-components"));
+const Label_1 = require("../Forms/Label/Label");
+const Input_1 = require("../Forms/Input/Input");
+const components_1 = require("../Select/components");
+const Menu_1 = require("../Menu/Menu");
+const MenuItem_1 = require("../MenuItem/MenuItem");
+const Buttons_1 = require("../Buttons");
+const styles_1 = require("../Forms/styles");
+const styled_1 = require("../styles/styled");
+const AUTOCOMPLETE_ITEM_GUTTER = 3;
+/**
+ * Space between one selected item and the other
+ */
+const AUTOCOMPLETE_ITEM_SPACER = 6;
+const AUTOCOMPLETE_ITEM_REMOVE_WIDTH = 20;
+exports.AutocompleteRoot = styled_components_1.default.div `
+  position: relative;
+`;
+exports.AutocompleteLabel = (0, styled_components_1.default)(Label_1.Label) ``;
+exports.AutocompleteWrap = (0, styled_components_1.default)(Input_1.InputWrap) `
+  ${styles_1.inputReset}
+`;
+exports.AutocompleteInner = (0, styled_components_1.default)(Input_1.InputMain) `
+  display: inline-flex;
+  flex-wrap: wrap;
+  margin: -${AUTOCOMPLETE_ITEM_SPACER}px;
+  margin-right: 0;
+`;
+exports.AutocompleteItem = styled_components_1.default.span `
+  position: relative;
+  display: inline-flex;
+  margin: ${AUTOCOMPLETE_ITEM_GUTTER}px;
+  max-width: calc(100% - 6px);
+  user-select: none;
+  align-items: center;
+  padding: 0 ${AUTOCOMPLETE_ITEM_REMOVE_WIDTH}px 0 ${AUTOCOMPLETE_ITEM_GUTTER}px;
+  font-size: 80%;
+  background: var(--accent400);
+
+  &:hover {
+    background: var(--accent300);
+    color: white;
+  }
+
+  &:focus {
+    outline: 0px;
+    background: var(--grey700);
+  }
+`;
+exports.AutocompleteItemLabel = styled_components_1.default.span `
+  padding: 0 ${AUTOCOMPLETE_ITEM_GUTTER}px;
+  ${styled_1.ellipsis}
+`;
+exports.AutocompleteItemRemove = styled_components_1.default.span `
+  ${Buttons_1.btnStyleReset}
+  position: absolute;
+  top: 0;
+  right: 0;
+  width: ${AUTOCOMPLETE_ITEM_REMOVE_WIDTH}px;
+  border: 0;
+  height: 100%;
+  color: inherit;
+  line-height: 1;
+`;
+exports.AutocompleteInputWrap = styled_components_1.default.div `
+  display: flex;
+  flex: 1;
+`;
+exports.AutocompleteInput = styled_components_1.default.input `
+  flex-grow: 1;
+  width: 0;
+  min-width: 30px;
+  border: 0;
+  padding: 0 ${AUTOCOMPLETE_ITEM_SPACER}px;
+  text-overflow: ellipsis;
+  background: transparent;
+
+  &:focus {
+    outline: none;
+  }
+`;
+/**
+ * This cannot be a button otherwise on `Enter` the form would submit instead
+ * of opening the dropdown or adding the selection. There are too many events
+ * to prevent if we were using a standard HTML `<button>`
+ */
+exports.AutocompleteInputArrow = (0, styled_components_1.default)(components_1.SelectArrow) ``;
+exports.AutocompleteMenu = (0, styled_components_1.default)(Menu_1.Menu) ``;
+exports.AutocompleteMenuItem = (0, styled_components_1.default)(MenuItem_1.MenuItem) ``;

package/node/Autocomplete/helpers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normaliseAutocompleteValue = void 0;
+const utils_1 = require("@koine/utils");
+// export function normaliseAutocompleteValue(
+//   value?: AutocompleteValue,
+//   asArray?: true
+// ): string[];
+// export function normaliseAutocompleteValue(
+//   value?: AutocompleteValue,
+//   asArray?: false
+// ): string;
+// export function normaliseAutocompleteValue(
+//   value?: AutocompleteValue,
+//   asArray?: undefined
+// ): string;
+function normaliseAutocompleteValue(value, asArray) {
+    if (!value) {
+        return asArray ? [""] : "";
+    }
+    if ((0, utils_1.isString)(value)) {
+        return asArray ? [value] : value;
+    }
+    if ((0, utils_1.isArray)(value)) {
+        const values = value.map((valueItem) => {
+            return (0, utils_1.isString)(valueItem) ? valueItem : valueItem.value;
+        });
+        return asArray ? values : values.join(",");
+    }
+    return asArray ? [value.value] : value.value;
+}
+exports.normaliseAutocompleteValue = normaliseAutocompleteValue;

package/node/Autocomplete/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Autocomplete = void 0;
+var AutocompleteMui_1 = require("./AutocompleteMui");
+Object.defineProperty(exports, "Autocomplete", { enumerable: true, get: function () { return AutocompleteMui_1.Autocomplete; } });
+// export type { AutocompleteProps } from "./AutocompleteReach";
+// export { Autocomplete } from "./AutocompleteReach";

package/node/Bg/BgColor.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BgContainer = exports.BgColorSkewed = exports.BgColor = void 0;
+const tslib_1 = require("tslib");
+const jsx_runtime_1 = require("react/jsx-runtime");
+const styled_components_1 = tslib_1.__importDefault(require("styled-components"));
+const styles_1 = require("../styles");
+const Grid_1 = require("../Grid");
+exports.BgColor = styled_components_1.default.div `
+  background: ${(p) => p.$bg};
+`;
+exports.BgColorSkewed = styled_components_1.default.div `
+  position: relative;
+  /* overflow: hidden; */
+
+  &:before {
+    z-index: -1;
+    content: "";
+    ${(p) => `
+      ${styles_1.overlay}
+      transform: ${p.$transform};
+      background: ${p.$bg};
+    `}
+  }
+`;
+const BgContainer = ({ color, skewY = 0, rotate = 0, scaleY = 1, // 0.85,
+scaleX = 1, // 4,
+perspective = 0, //100,
+...containerProps }) => {
+    let $transform = "";
+    if (skewY || rotate) {
+        $transform = `perspective(${perspective}vw) rotateY(${rotate}deg) skewY(${skewY}deg) scaleY(${scaleY}) scaleX(${scaleX})`;
+    }
+    return $transform ? ((0, jsx_runtime_1.jsx)(exports.BgColorSkewed, { "$bg": color, "$transform": $transform, children: (0, jsx_runtime_1.jsx)(Grid_1.Container, { style: { position: "relative" }, ...containerProps }) })) : ((0, jsx_runtime_1.jsx)(exports.BgColor, { "$bg": color, children: (0, jsx_runtime_1.jsx)(Grid_1.Container, { ...containerProps }) }));
+};
+exports.BgContainer = BgContainer;

package/node/Bg/BgPhoto.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BgPhoto = void 0;
+const tslib_1 = require("tslib");
+const jsx_runtime_1 = require("react/jsx-runtime");
+const styled_components_1 = tslib_1.__importDefault(require("styled-components"));
+const Grid_1 = require("../Grid");
+const Hidden_1 = require("../Hidden");
+const BgPhotoWrap = (0, styled_components_1.default)(Hidden_1.Hidden) `
+  z-index: -10;
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  overflow: hidden;
+  pointer-events: none;
+  background-repeat: no-repeat;
+  background-position: top left;
+  background-size: contain;
+  filter: hue-rotate(-36deg);
+  opacity: 0.8;
+`;
+const BgPhotoMask = (0, styled_components_1.default)(Grid_1.Container) `
+  position: relative;
+  min-height: 100%;
+
+  &:before {
+    content: "";
+    position: absolute;
+    top: 0;
+    height: 100%;
+    right: calc(100% - ${(p) => p.$overlap + 2}px);
+    width: ${(p) => {
+    const containerSizePx = p.theme.breakpoints[p.containerSize];
+    return `calc(((100vw - ${containerSizePx}px) / 2) + ${p.$overlap + 2}px)`;
+}};
+    background: linear-gradient(
+        90deg,
+        rgba(var(--bodyBg-rgb, 0)) 0%,
+        rgba(var(--bodyBg-rgb, 1)) 100%
+      ),
+      linear-gradient(
+        60deg,
+        rgba(var(--bodyBg-rgb, 0)) 0%,
+        rgba(var(--bodyBg-rgb, 1)) 70%
+      );
+  }
+
+  &:after {
+    content: "";
+    position: absolute;
+    top: 0;
+    height: 100%;
+    left: ${(p) => p.$overlap + 1}px;
+    width: 100vw;
+    background: var(--bodyBg);
+  }
+`;
+const BgPhoto = ({ src, containerSize = "xl", $overlap = 0, }) => {
+    const styledProps = { containerSize, $overlap };
+    return ((0, jsx_runtime_1.jsx)(BgPhotoWrap, { style: { backgroundImage: `url(${src})` }, "$max": "xxl", children: (0, jsx_runtime_1.jsx)(BgPhotoMask, { size: containerSize, ...styledProps }) }));
+};
+exports.BgPhoto = BgPhoto;

package/node/Bg/BgSvg.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BgSvg = void 0;
+const tslib_1 = require("tslib");
+const jsx_runtime_1 = require("react/jsx-runtime");
+const styled_components_1 = tslib_1.__importDefault(require("styled-components"));
+const Root = styled_components_1.default.svg `
+  position: fixed;
+  z-index: -2;
+  bottom: 0;
+  transform: rotate(180deg);
+  opacity: 0.9;
+`;
+/**
+ * Centered triangle shape
+ */
+const BgSvg = ({ color }) => {
+    return ((0, jsx_runtime_1.jsx)(Root, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 1200 120", preserveAspectRatio: "none", children: (0, jsx_runtime_1.jsx)("path", { d: "M1200 0L0 0 598.97 114.72 1200 0z", fill: color }) }));
+};
+exports.BgSvg = BgSvg;

package/node/Bg/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./BgColor"), exports);
+tslib_1.__exportStar(require("./BgPhoto"), exports);
+tslib_1.__exportStar(require("./BgSvg"), exports);

package/node/Breadcrumbs/Breadcrumbs.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoineBreadcrumbs = void 0;
+const tslib_1 = require("tslib");
+const jsx_runtime_1 = require("react/jsx-runtime");
+const styled_components_1 = tslib_1.__importStar(require("styled-components"));
+const framer_motion_1 = require("framer-motion");
+const md_1 = require("react-icons/md");
+const utils_1 = require("@koine/utils");
+const media_1 = require("../styles/media");
+const LINK_GUTTER_X = 10;
+const Root = styled_components_1.default.nav `
+  display: flex;
+  position: relative;
+`;
+const Inner = styled_components_1.default.div `
+  display: flex;
+  font-size: 11px;
+  color: var(--grey100);
+  ${media_1.min.sm} {
+    font-size: 12px;
+  }
+  ${media_1.max.lg} {
+    max-width: 100%;
+    overflow: hidden;
+    white-space: nowrap;
+  }
+`;
+const Item = (0, styled_components_1.default)(framer_motion_1.m.div) `
+  display: flex;
+  align-items: center;
+  /* margin: 0 10px 0 0; */
+
+  &:first-child {
+    margin-left: -${LINK_GUTTER_X / 2}px;
+  }
+  ${media_1.min.sm} {
+    &:first-child {
+      margin-left: -${LINK_GUTTER_X}px;
+    }
+  }
+`;
+const itemChild = (0, styled_components_1.css) `
+  display: block;
+  padding: 10px ${LINK_GUTTER_X / 2}px;
+
+  ${media_1.min.sm} {
+    padding: 10px ${LINK_GUTTER_X}px;
+  }
+`;
+const ItemLink = styled_components_1.default.a `
+  ${itemChild}
+  text-decoration: none;
+  &:hover {
+    text-decoration: underline;
+  }
+`;
+const ItemCurrent = styled_components_1.default.span `
+  ${itemChild}
+`;
+const ItemSeparator = (0, styled_components_1.default)(md_1.MdKeyboardArrowRight) ``;
+const KoineBreadcrumbs = ({ items = [], Link, ...props }) => {
+    if (!items.length) {
+        return null;
+    }
+    return ((0, jsx_runtime_1.jsx)(Root, { ...props, children: (0, jsx_runtime_1.jsx)(Inner, { children: items.map((item, idx) => ((0, jsx_runtime_1.jsxs)(Item, { initial: { opacity: 0, x: 20 }, animate: {
+                    opacity: 1,
+                    x: 0,
+                    transition: { delay: idx * 0.2 },
+                }, children: [item.url && ((0, jsx_runtime_1.jsx)(ItemLink, { as: Link, href: item.url, children: (0, utils_1.titleCase)(item.title) })), !item.url && (0, jsx_runtime_1.jsx)(ItemCurrent, { children: (0, utils_1.titleCase)(item.title) }), idx < items.length - 1 && (0, jsx_runtime_1.jsx)(ItemSeparator, {})] }, idx))) }) }));
+};
+exports.KoineBreadcrumbs = KoineBreadcrumbs;

package/node/Breadcrumbs/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./Breadcrumbs"), exports);