@orioro/react-ui-core 0.0.0

package/dist/makeLink/index.d.ts

@@ -0,0 +1 @@
+export * from './locationAwareLink';

package/dist/makeLink/locationAwareLink.d.ts

@@ -0,0 +1,290 @@
+import React from 'react';
+import type { LocationSensorState } from 'react-use/lib/useLocation';
+declare const DefaultLink: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, never>>;
+type LinkProps = Parameters<typeof DefaultLink>[0];
+declare function defaultCompare(location: LocationSensorState, href?: string): boolean;
+declare function defaultPropGetter(props: LinkProps, active: boolean): {
+    active: boolean;
+    ref?: React.LegacyRef<HTMLAnchorElement> | undefined;
+    key?: React.Key | null | undefined;
+    download?: any;
+    href?: string | undefined;
+    hrefLang?: string | undefined;
+    media?: string | undefined;
+    ping?: string | undefined;
+    target?: React.HTMLAttributeAnchorTarget | undefined;
+    type?: string | undefined;
+    referrerPolicy?: React.HTMLAttributeReferrerPolicy | undefined;
+    defaultChecked?: boolean | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    suppressContentEditableWarning?: boolean | undefined;
+    suppressHydrationWarning?: boolean | undefined;
+    accessKey?: string | undefined;
+    autoFocus?: boolean | undefined;
+    className?: string | undefined;
+    contentEditable?: "inherit" | (boolean | "false" | "true") | "plaintext-only" | undefined;
+    contextMenu?: string | undefined;
+    dir?: string | undefined;
+    draggable?: (boolean | "false" | "true") | undefined;
+    hidden?: boolean | undefined;
+    id?: string | undefined;
+    lang?: string | undefined;
+    nonce?: string | undefined;
+    slot?: string | undefined;
+    spellCheck?: (boolean | "false" | "true") | undefined;
+    style?: React.CSSProperties | undefined;
+    tabIndex?: number | undefined;
+    title?: string | undefined;
+    translate?: "yes" | "no" | undefined;
+    radioGroup?: string | undefined;
+    role?: React.AriaRole | undefined;
+    about?: string | undefined;
+    content?: string | undefined;
+    datatype?: string | undefined;
+    inlist?: any;
+    prefix?: string | undefined;
+    property?: string | undefined;
+    rel?: string | undefined;
+    resource?: string | undefined;
+    rev?: string | undefined;
+    typeof?: string | undefined;
+    vocab?: string | undefined;
+    autoCapitalize?: string | undefined;
+    autoCorrect?: string | undefined;
+    autoSave?: string | undefined;
+    color?: string | undefined;
+    itemProp?: string | undefined;
+    itemScope?: boolean | undefined;
+    itemType?: string | undefined;
+    itemID?: string | undefined;
+    itemRef?: string | undefined;
+    results?: number | undefined;
+    security?: string | undefined;
+    unselectable?: "on" | "off" | undefined;
+    inputMode?: "text" | "search" | "none" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
+    is?: string | undefined;
+    "aria-activedescendant"?: string | undefined;
+    "aria-atomic"?: (boolean | "false" | "true") | undefined;
+    "aria-autocomplete"?: "none" | "list" | "both" | "inline" | undefined;
+    "aria-braillelabel"?: string | undefined;
+    "aria-brailleroledescription"?: string | undefined;
+    "aria-busy"?: (boolean | "false" | "true") | undefined;
+    "aria-checked"?: boolean | "mixed" | "false" | "true" | undefined;
+    "aria-colcount"?: number | undefined;
+    "aria-colindex"?: number | undefined;
+    "aria-colindextext"?: string | undefined;
+    "aria-colspan"?: number | undefined;
+    "aria-controls"?: string | undefined;
+    "aria-current"?: boolean | "time" | "step" | "page" | "false" | "true" | "location" | "date" | undefined;
+    "aria-describedby"?: string | undefined;
+    "aria-description"?: string | undefined;
+    "aria-details"?: string | undefined;
+    "aria-disabled"?: (boolean | "false" | "true") | undefined;
+    "aria-dropeffect"?: "link" | "none" | "copy" | "move" | "execute" | "popup" | undefined;
+    "aria-errormessage"?: string | undefined;
+    "aria-expanded"?: (boolean | "false" | "true") | undefined;
+    "aria-flowto"?: string | undefined;
+    "aria-grabbed"?: (boolean | "false" | "true") | undefined;
+    "aria-haspopup"?: boolean | "dialog" | "menu" | "listbox" | "grid" | "false" | "true" | "tree" | undefined;
+    "aria-hidden"?: (boolean | "false" | "true") | undefined;
+    "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+    "aria-keyshortcuts"?: string | undefined;
+    "aria-label"?: string | undefined;
+    "aria-labelledby"?: string | undefined;
+    "aria-level"?: number | undefined;
+    "aria-live"?: "off" | "assertive" | "polite" | undefined;
+    "aria-modal"?: (boolean | "false" | "true") | undefined;
+    "aria-multiline"?: (boolean | "false" | "true") | undefined;
+    "aria-multiselectable"?: (boolean | "false" | "true") | undefined;
+    "aria-orientation"?: "horizontal" | "vertical" | undefined;
+    "aria-owns"?: string | undefined;
+    "aria-placeholder"?: string | undefined;
+    "aria-posinset"?: number | undefined;
+    "aria-pressed"?: boolean | "mixed" | "false" | "true" | undefined;
+    "aria-readonly"?: (boolean | "false" | "true") | undefined;
+    "aria-relevant"?: "text" | "all" | "additions" | "additions removals" | "additions text" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
+    "aria-required"?: (boolean | "false" | "true") | undefined;
+    "aria-roledescription"?: string | undefined;
+    "aria-rowcount"?: number | undefined;
+    "aria-rowindex"?: number | undefined;
+    "aria-rowindextext"?: string | undefined;
+    "aria-rowspan"?: number | undefined;
+    "aria-selected"?: (boolean | "false" | "true") | undefined;
+    "aria-setsize"?: number | undefined;
+    "aria-sort"?: "other" | "none" | "ascending" | "descending" | undefined;
+    "aria-valuemax"?: number | undefined;
+    "aria-valuemin"?: number | undefined;
+    "aria-valuenow"?: number | undefined;
+    "aria-valuetext"?: string | undefined;
+    children?: React.ReactNode;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined;
+    onCopy?: React.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+    onCopyCapture?: React.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+    onCut?: React.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+    onCutCapture?: React.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+    onPaste?: React.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+    onPasteCapture?: React.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+    onCompositionEnd?: React.CompositionEventHandler<HTMLAnchorElement> | undefined;
+    onCompositionEndCapture?: React.CompositionEventHandler<HTMLAnchorElement> | undefined;
+    onCompositionStart?: React.CompositionEventHandler<HTMLAnchorElement> | undefined;
+    onCompositionStartCapture?: React.CompositionEventHandler<HTMLAnchorElement> | undefined;
+    onCompositionUpdate?: React.CompositionEventHandler<HTMLAnchorElement> | undefined;
+    onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLAnchorElement> | undefined;
+    onFocus?: React.FocusEventHandler<HTMLAnchorElement> | undefined;
+    onFocusCapture?: React.FocusEventHandler<HTMLAnchorElement> | undefined;
+    onBlur?: React.FocusEventHandler<HTMLAnchorElement> | undefined;
+    onBlurCapture?: React.FocusEventHandler<HTMLAnchorElement> | undefined;
+    onChange?: React.FormEventHandler<HTMLAnchorElement> | undefined;
+    onChangeCapture?: React.FormEventHandler<HTMLAnchorElement> | undefined;
+    onBeforeInput?: React.FormEventHandler<HTMLAnchorElement> | undefined;
+    onBeforeInputCapture?: React.FormEventHandler<HTMLAnchorElement> | undefined;
+    onInput?: React.FormEventHandler<HTMLAnchorElement> | undefined;
+    onInputCapture?: React.FormEventHandler<HTMLAnchorElement> | undefined;
+    onReset?: React.FormEventHandler<HTMLAnchorElement> | undefined;
+    onResetCapture?: React.FormEventHandler<HTMLAnchorElement> | undefined;
+    onSubmit?: React.FormEventHandler<HTMLAnchorElement> | undefined;
+    onSubmitCapture?: React.FormEventHandler<HTMLAnchorElement> | undefined;
+    onInvalid?: React.FormEventHandler<HTMLAnchorElement> | undefined;
+    onInvalidCapture?: React.FormEventHandler<HTMLAnchorElement> | undefined;
+    onLoad?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onLoadCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onError?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onErrorCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onKeyDown?: React.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+    onKeyDownCapture?: React.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+    onKeyPress?: React.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+    onKeyPressCapture?: React.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+    onKeyUp?: React.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+    onKeyUpCapture?: React.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+    onAbort?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onAbortCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onCanPlay?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onCanPlayCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onCanPlayThrough?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onCanPlayThroughCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onDurationChange?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onDurationChangeCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onEmptied?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onEmptiedCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onEncrypted?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onEncryptedCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onEnded?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onEndedCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onLoadedData?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onLoadedDataCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onLoadedMetadata?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onLoadedMetadataCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onLoadStart?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onLoadStartCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onPause?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onPauseCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onPlay?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onPlayCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onPlaying?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onPlayingCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onProgress?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onProgressCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onRateChange?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onRateChangeCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onResize?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onResizeCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onSeeked?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onSeekedCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onSeeking?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onSeekingCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onStalled?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onStalledCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onSuspend?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onSuspendCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onTimeUpdate?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onTimeUpdateCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onVolumeChange?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onVolumeChangeCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onWaiting?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onWaitingCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onAuxClick?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onAuxClickCapture?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onClick?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onClickCapture?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onContextMenu?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onContextMenuCapture?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onDoubleClick?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onDoubleClickCapture?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onDrag?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDragCapture?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDragEnd?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDragEndCapture?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDragEnter?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDragEnterCapture?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDragExit?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDragExitCapture?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDragLeave?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDragLeaveCapture?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDragOver?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDragOverCapture?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDragStart?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDragStartCapture?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDrop?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onDropCapture?: React.DragEventHandler<HTMLAnchorElement> | undefined;
+    onMouseDown?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onMouseDownCapture?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onMouseEnter?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onMouseLeave?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onMouseMove?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onMouseMoveCapture?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onMouseOut?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onMouseOutCapture?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onMouseOver?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onMouseOverCapture?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onMouseUp?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onMouseUpCapture?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    onSelect?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onSelectCapture?: React.ReactEventHandler<HTMLAnchorElement> | undefined;
+    onTouchCancel?: React.TouchEventHandler<HTMLAnchorElement> | undefined;
+    onTouchCancelCapture?: React.TouchEventHandler<HTMLAnchorElement> | undefined;
+    onTouchEnd?: React.TouchEventHandler<HTMLAnchorElement> | undefined;
+    onTouchEndCapture?: React.TouchEventHandler<HTMLAnchorElement> | undefined;
+    onTouchMove?: React.TouchEventHandler<HTMLAnchorElement> | undefined;
+    onTouchMoveCapture?: React.TouchEventHandler<HTMLAnchorElement> | undefined;
+    onTouchStart?: React.TouchEventHandler<HTMLAnchorElement> | undefined;
+    onTouchStartCapture?: React.TouchEventHandler<HTMLAnchorElement> | undefined;
+    onPointerDown?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerDownCapture?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerMove?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerMoveCapture?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerUp?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerUpCapture?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerCancel?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerCancelCapture?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerEnter?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerEnterCapture?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerLeave?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerLeaveCapture?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerOver?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerOverCapture?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerOut?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onPointerOutCapture?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onGotPointerCapture?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onLostPointerCapture?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLAnchorElement> | undefined;
+    onScroll?: React.UIEventHandler<HTMLAnchorElement> | undefined;
+    onScrollCapture?: React.UIEventHandler<HTMLAnchorElement> | undefined;
+    onWheel?: React.WheelEventHandler<HTMLAnchorElement> | undefined;
+    onWheelCapture?: React.WheelEventHandler<HTMLAnchorElement> | undefined;
+    onAnimationStart?: React.AnimationEventHandler<HTMLAnchorElement> | undefined;
+    onAnimationStartCapture?: React.AnimationEventHandler<HTMLAnchorElement> | undefined;
+    onAnimationEnd?: React.AnimationEventHandler<HTMLAnchorElement> | undefined;
+    onAnimationEndCapture?: React.AnimationEventHandler<HTMLAnchorElement> | undefined;
+    onAnimationIteration?: React.AnimationEventHandler<HTMLAnchorElement> | undefined;
+    onAnimationIterationCapture?: React.AnimationEventHandler<HTMLAnchorElement> | undefined;
+    onTransitionEnd?: React.TransitionEventHandler<HTMLAnchorElement> | undefined;
+    onTransitionEndCapture?: React.TransitionEventHandler<HTMLAnchorElement> | undefined;
+};
+export declare function locationAwareLink<LocationAwareLinkProps extends {} = {}>(Link: React.FC<LinkProps & LocationAwareLinkProps>, { compare, props: getProps, }?: {
+    compare?: typeof defaultCompare;
+    props?: typeof defaultPropGetter;
+}): React.FC<LinkProps>;
+export {};

package/dist/makeListOf/index.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { AnyProps } from './types';
+type GetItemComponentProps<ItemType, ListProps, ItemComponent extends React.FC<{}>> = (item: ItemType, listProps: ListProps, index: number) => Parameters<ItemComponent>[0];
+type ContainerPropGetter<ComponentType extends React.FC, PropsInput extends AnyProps = AnyProps> = string[] | ((propsInput: PropsInput) => Parameters<ComponentType>[0]);
+export declare function makeListOf<ListProps extends AnyProps = AnyProps, ItemType = any, ItemComponentType extends React.FC = React.FC<AnyProps>, ContainerComponentType extends React.FC = React.FC<AnyProps>>(ItemComponent: ItemComponentType, { Container, containerProps, itemKey, itemProps: itemPropsGetter, }?: {
+    Container?: ContainerComponentType | typeof React.Fragment;
+    containerProps?: ContainerPropGetter<ContainerComponentType>;
+    itemKey?: (item: ItemType, index: number) => string | number;
+    itemProps?: GetItemComponentProps<ItemType, ContainerComponentType, ItemComponentType>;
+}): ({ items, ...listProps }: ListProps & {
+    items: ItemType[];
+}) => false | React.JSX.Element;
+export {};

package/dist/makeListOf/types.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export type AnyProps = {
+    [key: string]: any;
+};
+export type GetItemProps<ItemProps extends AnyProps = AnyProps, ItemType = any> = (item: ItemType, index: number) => ItemProps;
+export type GetItemKey<ItemType = any> = (item: ItemType, index: number) => number | string;
+export type ListOfProps<ItemComponentType extends React.FC<{}>, ItemType = any> = {
+    Component: ItemComponentType;
+    itemProps?: GetItemProps<Parameters<ItemComponentType>[0], ItemType>;
+    itemKey?: GetItemKey<ItemType>;
+    items?: ItemType[] | null;
+};

package/dist/mergeable/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { Merge } from 'type-fest';
+import { MergeableComponentInput } from './types';
+export * from './types';
+export declare function mergeable<ComponentProps extends {
+    children?: React.ReactNode;
+}>(Component: React.FC<ComponentProps>, defaultProps?: Partial<ComponentProps>): React.FC<Merge<Omit<ComponentProps, 'children'>, {
+    children: MergeableComponentInput;
+}>>;

package/dist/mergeable/types.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export type MergeableComponentInput = React.ReactNode | {
+    [key: string]: any;
+};

package/dist/recursiveRendererSystem/arrayRenderer.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { RecursiveRendererProps, RendererSchemaInput } from './types';
+declare function DefaultContainer(props: {
+    value: any[];
+    children: React.ReactNode;
+}): React.ReactNode;
+declare function DefaultItem(props: {
+    index: number;
+    schema: RendererSchemaInput;
+    value: any;
+    children: React.ReactNode;
+}): React.ReactNode;
+export declare function arrayRenderer(RendererComponent: React.FC<RecursiveRendererProps>, { Container, Item, }?: {
+    Container?: typeof DefaultContainer;
+    Item?: typeof DefaultItem;
+}): ({ ofType, value: arrayValue, }: {
+    ofType?: RendererSchemaInput | undefined;
+    value?: any[] | null | undefined;
+}) => false | React.JSX.Element;
+export {};

package/dist/recursiveRendererSystem/index.d.ts

@@ -0,0 +1,5 @@
+export * from './recursiveRendererSystem';
+export * from './arrayRenderer';
+export * from './objectRenderer';
+export * from './rendererSpecList';
+export * from './types';

package/dist/recursiveRendererSystem/objectRenderer.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import { FlexGridProps } from '../FlexGrid';
+import { RecursiveRendererProps, RendererSchemaInput } from './types';
+declare function DefaultContainer(props: {
+    value: {
+        [key: string]: any;
+    };
+    children: React.ReactNode;
+}): React.ReactNode;
+declare function DefaultProperty(props: {
+    property: string;
+    schema: RendererSchemaInput;
+    value: any;
+    children: React.ReactNode;
+}): React.ReactNode;
+type ObjectComponentProps = {
+    properties: {
+        [key: string]: RendererSchemaInput<{
+            label?: string;
+        }>;
+    };
+    layout?: (string | string[])[];
+    value?: {
+        [key: string]: any;
+    } | null;
+} & Omit<FlexGridProps, 'groups'>;
+export declare function objectRenderer(RendererComponent: React.FC<RecursiveRendererProps>, { Container, Property, }?: {
+    Container?: typeof DefaultContainer;
+    Property?: typeof DefaultProperty;
+}): ({ properties, layout, value: objectValue, gap, direction, ...flexGridProps }: ObjectComponentProps) => React.JSX.Element | null;
+export {};

package/dist/recursiveRendererSystem/recursiveRendererSystem.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { RecursiveRendererProps, RendererContextType, AnySchemaProps, RendererContextProviderProps } from './types';
+export declare function recursiveRendererSystem<SchemaProps extends {} = AnySchemaProps>(defaultContext?: RendererContextType): [
+    React.FC<RendererContextProviderProps>,
+    React.FC<RecursiveRendererProps<SchemaProps>>,
+    React.Context<RendererContextType>
+];

package/dist/recursiveRendererSystem/rendererSpecList.d.ts

@@ -0,0 +1,2 @@
+import { RendererSpecInput, RendererSpecList, RendererVariantFactoryList } from './types';
+export declare function rendererSpecList(specInput: RendererSpecInput, variants?: RendererVariantFactoryList): RendererSpecList;

package/dist/recursiveRendererSystem/stories/Output.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+declare const OutputProvider: React.FC<import("..").RendererContextProviderProps>, Output: React.FC<import("..").RecursiveRendererProps<import("..").AnySchemaProps>>;
+export { OutputProvider, Output };
+export declare function TextOutput({ value }: {
+    value: any;
+}): React.JSX.Element;
+export declare function NumberOutput({ value, format, }: {
+    value: any;
+    format?: 'percentage' | 'decimal' | string;
+}): React.JSX.Element | null;
+export declare const ObjectOutput: ({ properties, layout, value: objectValue, gap, direction, ...flexGridProps }: {
+    properties: {
+        [key: string]: import("..").RendererSchemaInput<{
+            label?: string | undefined;
+        }>;
+    };
+    layout?: (string | string[])[] | undefined;
+    value?: {
+        [key: string]: any;
+    } | null | undefined;
+} & Omit<import("../..").FlexGridProps, "groups">) => React.JSX.Element | null;
+export declare const ArrayOutput: ({ ofType, value: arrayValue, }: {
+    ofType?: import("..").RendererSchemaInput | undefined;
+    value?: any[] | null | undefined;
+}) => false | React.JSX.Element;
+export declare const DEFAULT_OUTPUT_RENDERERS: {
+    text: typeof TextOutput;
+    number: typeof NumberOutput;
+    object: ({ properties, layout, value: objectValue, gap, direction, ...flexGridProps }: {
+        properties: {
+            [key: string]: import("..").RendererSchemaInput<{
+                label?: string | undefined;
+            }>;
+        };
+        layout?: (string | string[])[] | undefined;
+        value?: {
+            [key: string]: any;
+        } | null | undefined;
+    } & Omit<import("../..").FlexGridProps, "groups">) => React.JSX.Element | null;
+    array: ({ ofType, value: arrayValue, }: {
+        ofType?: import("..").RendererSchemaInput | undefined;
+        value?: any[] | null | undefined;
+    }) => false | React.JSX.Element;
+    default: typeof TextOutput;
+};
+export declare const DEFAULT_OUTPUT_SPECS: import("..").RendererSpecList;

package/dist/recursiveRendererSystem/types.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="react" />
+import { Merge } from 'type-fest';
+export type RendererComponentInput<Props = any> = RendererComponent<Props> | (RendererComponent<Props> & {
+    [key: string]: React.FC<Props> | null;
+});
+export type RendererSpecInput = {
+    [key: string]: RendererComponentInput;
+    default: RendererComponentInput;
+};
+export type RendererComponent<Props = any> = React.FC<Props>;
+export type RendererContextType = {
+    renderers: RendererSpecList;
+    variant?: string;
+};
+export type RendererVariantFactory = (Component: RendererComponent, type: RendererSchemaType) => RendererComponent;
+export type RendererVariantFactoryList = {
+    [key: string]: RendererVariantFactory;
+};
+export type RendererSpec = {
+    default: RendererComponent;
+    [variantKey: string]: RendererComponent | null;
+};
+export type RendererSpecList = {
+    default: RendererSpec;
+    [typeKey: string]: RendererSpec;
+};
+export type AnySchemaProps = {
+    [key: string]: any;
+};
+export type RendererSchemaType = string;
+export type RendererSchema<SchemaProps extends {} = AnySchemaProps> = Merge<SchemaProps, {
+    type: RendererSchemaType;
+    variant?: string;
+}>;
+export type RendererSchemaInput<SchemaProps extends {} = AnySchemaProps> = RendererSchemaType | RendererSchema<SchemaProps>;
+export type RecursiveRendererProps<SchemaProps extends {} = AnySchemaProps, ValueType = any> = {
+    schema: RendererSchemaInput<SchemaProps>;
+    value?: ValueType;
+} & SchemaProps;
+export type RendererContextProviderProps = Partial<RendererContextType> & {
+    children: React.ReactNode;
+    inherit?: boolean;
+};

package/dist/replaceable/index.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { Merge } from 'type-fest';
+export declare function replaceable<ComponentProps extends {
+    children?: React.ReactNode;
+}>(Component: React.FC<ComponentProps>, defaultProps?: Partial<ComponentProps>): ({ children, ...props }: (import("type-fest").PickIndexSignature<Omit<ComponentProps, "children">> extends infer T_3 ? { [Key in keyof T_3 as Key extends never ? never : Key]: import("type-fest").PickIndexSignature<Omit<ComponentProps, "children">>[Key]; } : never) & import("type-fest").PickIndexSignature<{
+    children: any;
+}> & (import("type-fest").OmitIndexSignature<Omit<ComponentProps, "children">> extends infer T_4 ? { [Key_1 in keyof T_4 as Key_1 extends "children" ? never : Key_1]: import("type-fest").OmitIndexSignature<Omit<ComponentProps, "children">>[Key_1]; } : never) & import("type-fest").OmitIndexSignature<{
+    children: any;
+}> extends infer T ? { [KeyType_1 in keyof T]: ((import("type-fest").PickIndexSignature<Omit<ComponentProps, "children">> extends infer T_1 ? { [Key in keyof T_1 as Key extends never ? never : Key]: import("type-fest").PickIndexSignature<Omit<ComponentProps, "children">>[Key]; } : never) & import("type-fest").PickIndexSignature<{
+    children: any;
+}> & (import("type-fest").OmitIndexSignature<Omit<ComponentProps, "children">> extends infer T_2 ? { [Key_1 in keyof T_2 as Key_1 extends "children" ? never : Key_1]: import("type-fest").OmitIndexSignature<Omit<ComponentProps, "children">>[Key_1]; } : never) & import("type-fest").OmitIndexSignature<{
+    children: any;
+}>)[KeyType_1]; } : never) => React.JSX.Element | null;

package/dist/responsiveCss/index.d.ts

@@ -0,0 +1,15 @@
+import { ResponsiveValueInput } from './types';
+export * from './types';
+type BreakpointValue = string | number;
+type NamedBreakpointList = {
+    [key: string]: BreakpointValue;
+};
+type ResponsiveDeclarationsInput<T = any> = {
+    [key: string]: T;
+};
+type FormatDeclaration<T = any> = (input: T) => string;
+export declare function responsive<T>(declarationsInput: ResponsiveDeclarationsInput<T> | T, namedBreakpoints?: NamedBreakpointList, formatDeclaration?: FormatDeclaration<T>): string;
+export declare namespace responsive {
+    var property: typeof responsiveProperty;
+}
+export declare function responsiveProperty<T>(variableName: string, valueInput: ResponsiveValueInput<T>, namedBreakpoints?: NamedBreakpointList): string;

package/dist/responsiveCss/queryDeclarations.d.ts

@@ -0,0 +1,8 @@
+import { CSSDeclarationsInput } from '../util';
+type IntervalBoundary = string | number;
+export declare function queryDeclarations([minWidth, maxWidth]: [IntervalBoundary | null, IntervalBoundary | null], declarations: CSSDeclarationsInput, base?: string): string;
+export declare namespace queryDeclarations {
+    var smallerThan: (maxWidth: IntervalBoundary, declarations: string, base?: string | undefined) => string;
+    var largerThan: (minWidth: IntervalBoundary, declarations: string, base?: string | undefined) => string;
+}
+export {};

package/dist/responsiveCss/types.d.ts

@@ -0,0 +1,4 @@
+export type ResponsiveValue<T> = {
+    [key: string]: T;
+};
+export type ResponsiveValueInput<T> = T | ResponsiveValue<T>;

package/dist/s3Upload/index.d.ts

@@ -0,0 +1,3 @@
+export function s3Upload(files: any, getUploadParameters: any): (Uppy<Record<string, unknown>, Record<string, unknown>> | Promise<import("@uppy/core").UploadResult<Record<string, unknown>, Record<string, unknown>>>)[];
+export function s3UploadSingle(file: any, uploadParams: any): (Uppy<Record<string, unknown>, Record<string, unknown>> | Promise<import("@uppy/core").UploadResult<Record<string, unknown>, Record<string, unknown>>>)[];
+import Uppy from '@uppy/core';

package/dist/styleResolver/index.d.ts

@@ -0,0 +1,16 @@
+import { ResponsiveValueInput } from '../Responsive';
+import { ResolveValueFromTheme } from '../Theme';
+export type StyleSetter = (value: ResponsiveValueInput<any>) => {
+    [key: string]: ResponsiveValueInput<any>;
+};
+type StyleSetterInput = string | string[] | StyleSetter;
+export type StyleSpec = {
+    [key: string]: [ResolveValueFromTheme<any> | null, StyleSetter];
+};
+export type StyleSpecInput = {
+    [key: string]: StyleSetterInput | [ResolveValueFromTheme<any>, StyleSetterInput];
+};
+export declare function styleResolver(styleSpecInput: StyleSpecInput): (props: {
+    [key: string]: any;
+}) => ResponsiveValueInput<any>;
+export {};