@koine/react 1.0.10 → 1.0.11

package/Alert/Alert.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare type AlertProps = React.PropsWithChildren<{
+    $danger?: boolean;
+}>;
+export declare const Alert: ({ $danger, children, ...props }: AlertProps) => JSX.Element;

package/Alert/Alert.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import styled from "styled-components";
+const AlertRoot = styled.div `
+  font-size: 12px;
+  ${(p) => (p.$danger ? `color: var(--danger)` : "")}
+`;
+const AlertInner = styled.div `
+  padding: 1em;
+  background-color: rgba(0, 0, 0, 0.05);
+  /* border: 1px solid var(--grey700); */
+  /* background: pink; */
+  /* color: red; */
+`;
+export const Alert = ({ $danger, children, ...props }) => {
+    return (_jsx(AlertRoot, { "$danger": $danger, ...props, children: _jsx(AlertInner, { children: children }) }));
+};

package/Alert/index.d.ts

@@ -0,0 +1 @@
+export * from "./Alert";

package/Alert/index.js

@@ -0,0 +1 @@
+export * from "./Alert";

package/Alert/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/Alert/index.js",
+  "types": "./index.d.ts"
+}

package/Animations/Reveal.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { UseRevealOptions } from "./useReveal";
+export declare type RevealProps = React.PropsWithChildren<UseRevealOptions>;
+export declare const Reveal: ({ children, direction, offsetStartY, offsetEndY, offsetStartX, ...props }: RevealProps) => JSX.Element;

package/Animations/Reveal.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { motion, useViewportScroll, useTransform, useSpring, useReducedMotion, } from "framer-motion";
+import { useReveal } from "./useReveal";
+export const Reveal = ({ children, direction, offsetStartY, offsetEndY, offsetStartX, ...props }) => {
+    const effectOptions = { direction, offsetStartY, offsetEndY, offsetStartX };
+    const prefersReducedMotion = useReducedMotion();
+    const { ref, startY, endY, startX } = useReveal(effectOptions);
+    const { scrollYProgress } = useViewportScroll();
+    const xRange = useTransform(scrollYProgress, [startY, endY], [startX, 0]);
+    const opacityRange = useTransform(scrollYProgress, [startY, endY], [0, 1]);
+    const x = useSpring(xRange, { stiffness: 400, damping: 90 });
+    const opacity = useSpring(opacityRange);
+    // console.log("start, end", startY, endY)
+    return (_jsx(motion.div, { ...props, ref: ref, style: prefersReducedMotion ? {} : { x, opacity }, children: children }));
+};

package/Animations/Underline.d.ts

@@ -0,0 +1 @@
+export declare const UnderlineSkewed: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLElement, import("framer-motion").HTMLMotionProps<"i">>, import("styled-components").DefaultTheme, {}, never>;

package/Animations/Underline.js

@@ -0,0 +1,15 @@
+import styled from "styled-components";
+import { m } from "framer-motion";
+export const UnderlineSkewed = styled(m.i) `
+  display: block;
+  position: absolute;
+  top: 50%;
+  left: 15%;
+  right: 15%;
+  height: 20px;
+  margin-top: -10px;
+  z-index: 0;
+  pointer-events: none;
+  background: var(--accent400);
+  transform: skewY(-5deg);
+`;

package/Animations/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Reveal";
+export * from "./Underline";
+export * from "./useReveal";

package/Animations/index.js

@@ -0,0 +1,3 @@
+export * from "./Reveal";
+export * from "./Underline";
+export * from "./useReveal";

package/Animations/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/Animations/index.js",
+  "types": "./index.d.ts"
+}

package/Animations/useReveal.d.ts

@@ -0,0 +1,33 @@
+export declare type UseRevealOptions = {
+    /**
+     * @default "left"
+     */
+    direction?: "left" | "right";
+    /**
+     * A number that represents the offset to start the animations, giving `-1`
+     * means that the animation will start when the scroll position is at
+     * 100% higher than the given element. Giving `2` the animation will starts
+     * when the scroll reached two times the height of the given element below
+     * the top edge of the element itself
+     *
+     * @default -2
+     */
+    offsetStartY?: number;
+    /**
+     * When 0 it defaults to the same as the offsetStartY
+     * @default 0
+     */
+    offsetEndY?: number;
+    /**
+     * A value from `0` to `1` representing a proportion of the element width
+     * or "all" to make it completely out of the viewport
+     * @default "all"
+     * */
+    offsetStartX?: number | "all";
+};
+export declare function useReveal<T extends HTMLElement = HTMLDivElement>({ direction, offsetStartY, offsetEndY, offsetStartX, }: UseRevealOptions): {
+    ref: import("react").RefObject<T>;
+    startY: number;
+    endY: number;
+    startX: number;
+};

package/Animations/useReveal.js

@@ -0,0 +1,70 @@
+import { useRef, useState, useEffect } from "react";
+export function useReveal({ direction = "left", offsetStartY = -2, offsetEndY = 0, offsetStartX = "all", }) {
+    const ref = useRef(null);
+    const [startY, setStartY] = useState(0);
+    const [endY, setEndY] = useState(0);
+    const [startX, setStartX] = useState(0);
+    useEffect(() => {
+        if (!ref.current) {
+            return;
+        }
+        const rect = ref.current.getBoundingClientRect();
+        // scroll position from top of the window
+        const scrollTop = window.scrollY || document.documentElement.scrollTop;
+        const elementHeight = rect.height;
+        // rect.top is the distance from the currently visible viewport to the top
+        // of the given element
+        // so distanceTop is the distance between the top edge of the window and the
+        // top edge of the given element
+        const elementTop = rect.top;
+        const distanceTop = elementTop + scrollTop;
+        const offsetTop = offsetStartY ? elementHeight * offsetStartY : 0;
+        const offsetBottom = offsetEndY ? elementHeight * offsetEndY : offsetTop;
+        // the distance of the element from the top divided by the full height
+        // of the window gives back the start position of the given element in
+        // a scale from 0 to 1
+        const startY = (distanceTop + offsetTop) / document.body.clientHeight;
+        // same for the end, we just add the given element height to the first value
+        const endY = (distanceTop + elementHeight + offsetBottom) / document.body.clientHeight;
+        let startX;
+        if (offsetStartX === "all") {
+            startX = direction === "left" ? -rect.right : rect.left;
+        }
+        else {
+            startX = rect.width * offsetStartX;
+            startX = direction === "left" ? -startX : startX;
+        }
+        // addMarker(startY + "px");
+        // addMarker(endY + "px");
+        // console.log("start", startY, "end", endY, "startX", startX)
+        setStartY(startY);
+        setEndY(endY);
+        setStartX(startX);
+        // addMarker(startY * 100 + "%", "blue", "fixed");
+        // addMarker(endY * 100 + "%", "blue", "fixed");
+    }, [
+        setStartY,
+        setEndY,
+        setStartX,
+        offsetStartY,
+        offsetEndY,
+        offsetStartX,
+        direction,
+    ]);
+    return { ref, startY, endY, startX };
+}
+// function addMarker(top: string, color = "red", position = "absolute") {
+//   const div = document.createElement("div");
+//   div.setAttribute(
+//     "style",
+//     `
+//     position: ${position};
+//     top: ${top};
+//     left: 0;
+//     right: 0;
+//     height: 1px;
+//     background: ${color};
+//   `
+//   );
+//   document.body.appendChild(div);
+// }

package/Autocomplete/AutocompleteDownshift.d.ts

@@ -0,0 +1 @@
+export declare const Autocomplete: null;

package/Autocomplete/AutocompleteDownshift.js

@@ -0,0 +1,158 @@
+// TODO: remove, just use mui version...
+export const Autocomplete = null;
+// import {
+//   forwardRef,
+//   useCallback,
+//   useState,
+//   ForwardedRef,
+//   ReactNode,
+//   ComponentPropsWithRef,
+//   CSSProperties,
+// } from "react";
+// import { useCombobox } from "downshift";
+// import { SetRequired } from "@koine/utils";
+// // import debounce from "lodash.debounce";
+// import {
+//   AutocompleteRoot,
+//   AutocompleteLabel,
+//   AutocompleteInputWrap,
+//   AutocompleteInput,
+//   AutocompleteInputArrow,
+//   AutocompleteMenu,
+//   AutocompleteMenuItem,
+// } from "./components";
+// import { defaultOptionsFilterFn, triggerOnChange } from "../Forms/helpers";
+// import { InputProgress } from "../Forms/styles";
+// export type AutocompleteOption = Option;
+// export type AutocompleteValue = null | AutocompleteOption;
+// export type AutocompleteProps = SetRequired<
+//   Omit<ComponentPropsWithRef<"input">, "onSelect">,
+//   "onChange" | "name"
+// > & {
+//   freeSolo?: boolean;
+//   onSelect?: (option?: AutocompleteValue) => 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(
+//     {
+//       freeSolo,
+//       onSelect,
+//       options = [],
+//       label,
+//       name,
+//       value,
+//       onChange,
+//       loadOptions,
+//       className,
+//       style,
+//       $ref,
+//       ...props
+//     },
+//     ref
+//   ) {
+//     const [items, setItems] = useState(options);
+//     const [loading, setLoading] = useState(false);
+//     const triggerChange = useCallback(
+//       (selectedItem?: AutocompleteValue, inputValue?: string) => {
+//         const value = freeSolo ? inputValue : selectedItem?.value;
+//         triggerOnChange(onChange, name, value || "");
+//         if (onSelect) onSelect(selectedItem);
+//       },
+//       [onChange, onSelect, name, freeSolo]
+//     );
+//     const handleInputValueChange = useCallback(
+//       async ({ inputValue }) => {
+//         if (inputValue) {
+//           if (loadOptions) {
+//             setLoading(true);
+//             try {
+//               const newOptions = await loadOptions(inputValue);
+//               setItems(newOptions);
+//             } catch (e) {}
+//             setLoading(false);
+//           } else {
+//             setItems(defaultOptionsFilterFn(options, inputValue));
+//           }
+//         } else {
+//           setItems(options);
+//           // clear like behaviour
+//           triggerChange({ value: "", label: "" });
+//         }
+//       },
+//       [loadOptions, triggerChange]
+//     );
+//     const {
+//       isOpen,
+//       // selectedItem,
+//       getToggleButtonProps,
+//       getLabelProps,
+//       getMenuProps,
+//       getInputProps,
+//       getComboboxProps,
+//       highlightedIndex,
+//       getItemProps,
+//       openMenu,
+//     } = useCombobox<null | AutocompleteOption>({
+//       id: `Autocomplete-${name}`,
+//       items,
+//       // initialInputValue: value,
+//       onSelectedItemChange: ({ selectedItem, inputValue }) => {
+//         triggerChange(selectedItem, inputValue);
+//       },
+//       // itemToString: (item) => (item ? item.label || item.value : ""),
+//       onInputValueChange: handleInputValueChange,
+//     });
+//     // const debouncedInputValueChangeHandler = useCallback(
+//     //   debounce(handleInputValueChange, 200),
+//     //   [handleInputValueChange]
+//     // );
+//     return (
+//       <AutocompleteRoot className={className} style={style}>
+//         {label && (
+//           <AutocompleteLabel {...getLabelProps()}>{label}</AutocompleteLabel>
+//         )}
+//         <AutocompleteInputWrap {...getComboboxProps()}>
+//           <AutocompleteInput
+//             {...getInputProps({
+//               onFocus: openMenu,
+//               onClick: openMenu,
+//               ref: $ref || ref,
+//               // itemRef: ref,
+//             })}
+//             {...props}
+//           />
+//           {!!items.length && (
+//             <AutocompleteInputArrow
+//               {...getToggleButtonProps()}
+//               aria-label={"toggle menu"}
+//             />
+//           )}
+//           {loading && <InputProgress />}
+//         </AutocompleteInputWrap>
+//         <AutocompleteMenu {...getMenuProps()}>
+//           {isOpen &&
+//             items
+//               // .filter(item => !inputValue || item.includes(inputValue))
+//               .map(
+//                 (item, index) =>
+//                   item && (
+//                     <AutocompleteMenuItem
+//                       $active={highlightedIndex === index}
+//                       key={`${item.value}${index}`}
+//                       {...getItemProps({ item, index })}
+//                     >
+//                       {item.label}
+//                     </AutocompleteMenuItem>
+//                   )
+//               )}
+//         </AutocompleteMenu>
+//       </AutocompleteRoot>
+//     );
+//   }
+// );

package/Autocomplete/AutocompleteDownshiftMultiselect.d.ts

@@ -0,0 +1 @@
+export declare const Autocomplete: null;