@storybook/components 6.5.0-alpha.9 → 6.5.0-beta.2

package/dist/ts3.9/_modules/@popperjs-core-index.d.ts

@@ -0,0 +1 @@
+export * from "./@popperjs-core-lib-index";

package/dist/ts3.9/_modules/@popperjs-core-lib-createPopper.d.ts

@@ -0,0 +1,9 @@
+import type { OptionsGeneric, Modifier, Instance, VirtualElement } from "./@popperjs-core-lib-types";
+import detectOverflow from "./@popperjs-core-lib-utils-detectOverflow";
+declare type PopperGeneratorArgs = {
+    defaultModifiers?: Array<Modifier<any, any>>;
+    defaultOptions?: Partial<OptionsGeneric<any>>;
+};
+export declare function popperGenerator(generatorOptions?: PopperGeneratorArgs): <TModifier extends Partial<Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<OptionsGeneric<TModifier>>) => Instance;
+export declare const createPopper: <TModifier extends Partial<Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<OptionsGeneric<TModifier>>) => Instance;
+export { detectOverflow };

package/dist/ts3.9/_modules/@popperjs-core-lib-enums.d.ts

@@ -0,0 +1,34 @@
+export declare const top: "top";
+export declare const bottom: "bottom";
+export declare const right: "right";
+export declare const left: "left";
+export declare const auto: "auto";
+export declare type BasePlacement = typeof top | typeof bottom | typeof right | typeof left;
+export declare const basePlacements: Array<BasePlacement>;
+export declare const start: "start";
+export declare const end: "end";
+export declare type Variation = typeof start | typeof end;
+export declare const clippingParents: "clippingParents";
+export declare const viewport: "viewport";
+export declare type Boundary = Element | Array<Element> | typeof clippingParents;
+export declare type RootBoundary = typeof viewport | "document";
+export declare const popper: "popper";
+export declare const reference: "reference";
+export declare type Context = typeof popper | typeof reference;
+export declare type VariationPlacement = "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
+export declare type AutoPlacement = "auto" | "auto-start" | "auto-end";
+export declare type ComputedPlacement = VariationPlacement | BasePlacement;
+export declare type Placement = AutoPlacement | BasePlacement | VariationPlacement;
+export declare const variationPlacements: Array<VariationPlacement>;
+export declare const placements: Array<Placement>;
+export declare const beforeRead: "beforeRead";
+export declare const read: "read";
+export declare const afterRead: "afterRead";
+export declare const beforeMain: "beforeMain";
+export declare const main: "main";
+export declare const afterMain: "afterMain";
+export declare const beforeWrite: "beforeWrite";
+export declare const write: "write";
+export declare const afterWrite: "afterWrite";
+export declare const modifierPhases: Array<ModifierPhases>;
+export declare type ModifierPhases = typeof beforeRead | typeof read | typeof afterRead | typeof beforeMain | typeof main | typeof afterMain | typeof beforeWrite | typeof write | typeof afterWrite;

package/dist/ts3.9/_modules/@popperjs-core-lib-index.d.ts

@@ -0,0 +1,6 @@
+export * from "./@popperjs-core-lib-types";
+export * from "./@popperjs-core-lib-enums";
+export * from "./@popperjs-core-lib-modifiers-index";
+export { popperGenerator, detectOverflow, createPopper as createPopperBase } from "./@popperjs-core-lib-createPopper";
+export { createPopper } from "./@popperjs-core-lib-popper";
+export { createPopper as createPopperLite } from "./@popperjs-core-lib-popper-lite";

package/dist/ts3.9/_modules/@popperjs-core-lib-modifiers-applyStyles.d.ts

@@ -0,0 +1,4 @@
+import type { Modifier } from "./@popperjs-core-lib-types";
+export declare type ApplyStylesModifier = Modifier<"applyStyles", {}>;
+declare const _default: ApplyStylesModifier;
+export default _default;

package/dist/ts3.9/_modules/@popperjs-core-lib-modifiers-arrow.d.ts

@@ -0,0 +1,13 @@
+import type { Modifier, Padding, Rect } from "./@popperjs-core-lib-types";
+import type { Placement } from "./@popperjs-core-lib-enums";
+export declare type Options = {
+    element: HTMLElement | string | null;
+    padding: Padding | ((arg0: {
+        popper: Rect;
+        reference: Rect;
+        placement: Placement;
+    }) => Padding);
+};
+export declare type ArrowModifier = Modifier<"arrow", Options>;
+declare const _default: ArrowModifier;
+export default _default;

package/dist/ts3.9/_modules/@popperjs-core-lib-modifiers-computeStyles.d.ts

@@ -0,0 +1,38 @@
+import type { PositioningStrategy, Offsets, Modifier, Rect } from "./@popperjs-core-lib-types";
+import { BasePlacement, Variation } from "./@popperjs-core-lib-enums";
+export declare type RoundOffsets = (offsets: Partial<{
+    x: number;
+    y: number;
+    centerOffset: number;
+}>) => Offsets;
+export declare type Options = {
+    gpuAcceleration: boolean;
+    adaptive: boolean;
+    roundOffsets?: boolean | RoundOffsets;
+};
+export declare function mapToStyles({ popper, popperRect, placement, variation, offsets, position, gpuAcceleration, adaptive, roundOffsets, isFixed }: {
+    popper: HTMLElement;
+    popperRect: Rect;
+    placement: BasePlacement;
+    variation: Variation | null | undefined;
+    offsets: Partial<{
+        x: number;
+        y: number;
+        centerOffset: number;
+    }>;
+    position: PositioningStrategy;
+    gpuAcceleration: boolean;
+    adaptive: boolean;
+    roundOffsets: boolean | RoundOffsets;
+    isFixed: boolean;
+}): {
+    transform: string;
+    top: string;
+    right: string;
+    bottom: string;
+    left: string;
+    position: PositioningStrategy;
+};
+export declare type ComputeStylesModifier = Modifier<"computeStyles", Options>;
+declare const _default: ComputeStylesModifier;
+export default _default;

package/dist/ts3.9/_modules/@popperjs-core-lib-modifiers-eventListeners.d.ts

@@ -0,0 +1,8 @@
+import type { Modifier } from "./@popperjs-core-lib-types";
+export declare type Options = {
+    scroll: boolean;
+    resize: boolean;
+};
+export declare type EventListenersModifier = Modifier<"eventListeners", Options>;
+declare const _default: EventListenersModifier;
+export default _default;

package/dist/ts3.9/_modules/@popperjs-core-lib-modifiers-flip.d.ts

@@ -0,0 +1,16 @@
+import type { Placement, Boundary, RootBoundary } from "./@popperjs-core-lib-enums";
+import type { Modifier, Padding } from "./@popperjs-core-lib-types";
+export declare type Options = {
+    mainAxis: boolean;
+    altAxis: boolean;
+    fallbackPlacements: Array<Placement>;
+    padding: Padding;
+    boundary: Boundary;
+    rootBoundary: RootBoundary;
+    altBoundary: boolean;
+    flipVariations: boolean;
+    allowedAutoPlacements: Array<Placement>;
+};
+export declare type FlipModifier = Modifier<"flip", Options>;
+declare const _default: FlipModifier;
+export default _default;

package/dist/ts3.9/_modules/@popperjs-core-lib-modifiers-hide.d.ts

@@ -0,0 +1,4 @@
+import type { Modifier } from "./@popperjs-core-lib-types";
+export declare type HideModifier = Modifier<"hide", {}>;
+declare const _default: HideModifier;
+export default _default;

package/dist/ts3.9/_modules/@popperjs-core-lib-modifiers-index.d.ts

@@ -0,0 +1,9 @@
+export { default as applyStyles } from "./@popperjs-core-lib-modifiers-applyStyles";
+export { default as arrow } from "./@popperjs-core-lib-modifiers-arrow";
+export { default as computeStyles } from "./@popperjs-core-lib-modifiers-computeStyles";
+export { default as eventListeners } from "./@popperjs-core-lib-modifiers-eventListeners";
+export { default as flip } from "./@popperjs-core-lib-modifiers-flip";
+export { default as hide } from "./@popperjs-core-lib-modifiers-hide";
+export { default as offset } from "./@popperjs-core-lib-modifiers-offset";
+export { default as popperOffsets } from "./@popperjs-core-lib-modifiers-popperOffsets";
+export { default as preventOverflow } from "./@popperjs-core-lib-modifiers-preventOverflow";

package/dist/ts3.9/_modules/@popperjs-core-lib-modifiers-offset.d.ts

@@ -0,0 +1,18 @@
+import type { Placement } from "./@popperjs-core-lib-enums";
+import type { Modifier, Rect, Offsets } from "./@popperjs-core-lib-types";
+export declare type OffsetsFunction = (arg0: {
+    popper: Rect;
+    reference: Rect;
+    placement: Placement;
+}) => [number | null | undefined, number | null | undefined];
+declare type Offset = OffsetsFunction | [number | null | undefined, number | null | undefined];
+export declare type Options = {
+    offset: Offset;
+};
+export declare function distanceAndSkiddingToXY(placement: Placement, rects: {
+    popper: Rect;
+    reference: Rect;
+}, offset: Offset): Offsets;
+export declare type OffsetModifier = Modifier<"offset", Options>;
+declare const _default: OffsetModifier;
+export default _default;

package/dist/ts3.9/_modules/@popperjs-core-lib-modifiers-popperOffsets.d.ts

@@ -0,0 +1,4 @@
+import type { Modifier } from "./@popperjs-core-lib-types";
+export declare type PopperOffsetsModifier = Modifier<"popperOffsets", {}>;
+declare const _default: PopperOffsetsModifier;
+export default _default;

package/dist/ts3.9/_modules/@popperjs-core-lib-modifiers-preventOverflow.d.ts

@@ -0,0 +1,30 @@
+import type { Placement, Boundary, RootBoundary } from "./@popperjs-core-lib-enums";
+import type { Rect, Modifier, Padding } from "./@popperjs-core-lib-types";
+declare type TetherOffset = ((arg0: {
+    popper: Rect;
+    reference: Rect;
+    placement: Placement;
+}) => number | {
+    mainAxis: number;
+    altAxis: number;
+}) | number | {
+    mainAxis: number;
+    altAxis: number;
+};
+export declare type Options = {
+    mainAxis: boolean;
+    altAxis: boolean;
+    boundary: Boundary;
+    rootBoundary: RootBoundary;
+    altBoundary: boolean;
+    /**
+     * Allows the popper to overflow from its boundaries to keep it near its
+     * reference element
+     */
+    tether: boolean;
+    tetherOffset: TetherOffset;
+    padding: Padding;
+};
+export declare type PreventOverflowModifier = Modifier<"preventOverflow", Options>;
+declare const _default: PreventOverflowModifier;
+export default _default;

package/dist/ts3.9/_modules/@popperjs-core-lib-popper-lite.d.ts

@@ -0,0 +1,5 @@
+import { popperGenerator, detectOverflow } from "./@popperjs-core-lib-createPopper";
+export * from "./@popperjs-core-lib-types";
+declare const defaultModifiers: (import("./@popperjs-core-lib-modifiers-popperOffsets").PopperOffsetsModifier | import("./@popperjs-core-lib-modifiers-eventListeners").EventListenersModifier | import("./@popperjs-core-lib-modifiers-computeStyles").ComputeStylesModifier | import("./@popperjs-core-lib-modifiers-applyStyles").ApplyStylesModifier)[];
+declare const createPopper: <TModifier extends Partial<import("./@popperjs-core-lib-types").Modifier<any, any>>>(reference: Element | import("./@popperjs-core-lib-types").VirtualElement, popper: HTMLElement, options?: Partial<import("./@popperjs-core-lib-types").OptionsGeneric<TModifier>>) => import("./@popperjs-core-lib-types").Instance;
+export { createPopper, popperGenerator, defaultModifiers, detectOverflow };

package/dist/ts3.9/_modules/@popperjs-core-lib-popper.d.ts

@@ -0,0 +1,7 @@
+import { popperGenerator, detectOverflow } from "./@popperjs-core-lib-createPopper";
+export * from "./@popperjs-core-lib-types";
+declare const defaultModifiers: (import("./@popperjs-core-lib-modifiers-popperOffsets").PopperOffsetsModifier | import("./@popperjs-core-lib-modifiers-flip").FlipModifier | import("./@popperjs-core-lib-modifiers-hide").HideModifier | import("./@popperjs-core-lib-modifiers-offset").OffsetModifier | import("./@popperjs-core-lib-modifiers-eventListeners").EventListenersModifier | import("./@popperjs-core-lib-modifiers-computeStyles").ComputeStylesModifier | import("./@popperjs-core-lib-modifiers-arrow").ArrowModifier | import("./@popperjs-core-lib-modifiers-preventOverflow").PreventOverflowModifier | import("./@popperjs-core-lib-modifiers-applyStyles").ApplyStylesModifier)[];
+declare const createPopper: <TModifier extends Partial<import("./@popperjs-core-lib-types").Modifier<any, any>>>(reference: Element | import("./@popperjs-core-lib-types").VirtualElement, popper: HTMLElement, options?: Partial<import("./@popperjs-core-lib-types").OptionsGeneric<TModifier>>) => import("./@popperjs-core-lib-types").Instance;
+export { createPopper, popperGenerator, defaultModifiers, detectOverflow };
+export { createPopper as createPopperLite } from "./@popperjs-core-lib-popper-lite";
+export * from "./@popperjs-core-lib-modifiers-index";

package/dist/ts3.9/_modules/@popperjs-core-lib-types.d.ts

@@ -0,0 +1,167 @@
+import type { Placement, ModifierPhases } from "./@popperjs-core-lib-enums";
+import type { PopperOffsetsModifier } from "./@popperjs-core-lib-modifiers-popperOffsets";
+import type { FlipModifier } from "./@popperjs-core-lib-modifiers-flip";
+import type { HideModifier } from "./@popperjs-core-lib-modifiers-hide";
+import type { OffsetModifier } from "./@popperjs-core-lib-modifiers-offset";
+import type { EventListenersModifier } from "./@popperjs-core-lib-modifiers-eventListeners";
+import type { ComputeStylesModifier } from "./@popperjs-core-lib-modifiers-computeStyles";
+import type { ArrowModifier } from "./@popperjs-core-lib-modifiers-arrow";
+import type { PreventOverflowModifier } from "./@popperjs-core-lib-modifiers-preventOverflow";
+import type { ApplyStylesModifier } from "./@popperjs-core-lib-modifiers-applyStyles";
+export declare type Obj = {
+    [key: string]: any;
+};
+export declare type VisualViewport = EventTarget & {
+    width: number;
+    height: number;
+    offsetLeft: number;
+    offsetTop: number;
+    scale: number;
+};
+export declare type Window = {
+    innerHeight: number;
+    offsetHeight: number;
+    innerWidth: number;
+    offsetWidth: number;
+    pageXOffset: number;
+    pageYOffset: number;
+    getComputedStyle: typeof getComputedStyle;
+    addEventListener(type: any, listener: any, optionsOrUseCapture?: any): void;
+    removeEventListener(type: any, listener: any, optionsOrUseCapture?: any): void;
+    Element: Element;
+    HTMLElement: HTMLElement;
+    Node: Node;
+    toString(): "[object Window]";
+    devicePixelRatio: number;
+    visualViewport?: VisualViewport;
+    ShadowRoot: ShadowRoot;
+};
+export declare type Rect = {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+};
+export declare type Offsets = {
+    y: number;
+    x: number;
+};
+export declare type PositioningStrategy = "absolute" | "fixed";
+export declare type StateRects = {
+    reference: Rect;
+    popper: Rect;
+};
+export declare type StateOffsets = {
+    popper: Offsets;
+    arrow?: Offsets;
+};
+declare type OffsetData = {
+    [key in Placement]?: Offsets;
+};
+export declare type State = {
+    elements: {
+        reference: Element | VirtualElement;
+        popper: HTMLElement;
+        arrow?: HTMLElement;
+    };
+    options: OptionsGeneric<any>;
+    placement: Placement;
+    strategy: PositioningStrategy;
+    orderedModifiers: Array<Modifier<any, any>>;
+    rects: StateRects;
+    scrollParents: {
+        reference: Array<Element | Window | VisualViewport>;
+        popper: Array<Element | Window | VisualViewport>;
+    };
+    styles: {
+        [key: string]: Partial<CSSStyleDeclaration>;
+    };
+    attributes: {
+        [key: string]: {
+            [key: string]: string | boolean;
+        };
+    };
+    modifiersData: {
+        arrow?: {
+            x?: number;
+            y?: number;
+            centerOffset: number;
+        };
+        hide?: {
+            isReferenceHidden: boolean;
+            hasPopperEscaped: boolean;
+            referenceClippingOffsets: SideObject;
+            popperEscapeOffsets: SideObject;
+        };
+        offset?: OffsetData;
+        preventOverflow?: Offsets;
+        popperOffsets?: Offsets;
+        [key: string]: any;
+    };
+    reset: boolean;
+};
+declare type SetAction<S> = S | ((prev: S) => S);
+export declare type Instance = {
+    state: State;
+    destroy: () => void;
+    forceUpdate: () => void;
+    update: () => Promise<Partial<State>>;
+    setOptions: (setOptionsAction: SetAction<Partial<OptionsGeneric<any>>>) => Promise<Partial<State>>;
+};
+export declare type ModifierArguments<Options extends Obj> = {
+    state: State;
+    instance: Instance;
+    options: Partial<Options>;
+    name: string;
+};
+export declare type Modifier<Name, Options> = {
+    name: Name;
+    enabled: boolean;
+    phase: ModifierPhases;
+    requires?: Array<string>;
+    requiresIfExists?: Array<string>;
+    fn: (arg0: ModifierArguments<Options>) => State | void;
+    effect?: (arg0: ModifierArguments<Options>) => (() => void) | void;
+    options?: Partial<Options>;
+    data?: Obj;
+};
+export declare type StrictModifiers = Partial<OffsetModifier> | Partial<ApplyStylesModifier> | Partial<ArrowModifier> | Partial<HideModifier> | Partial<ComputeStylesModifier> | Partial<EventListenersModifier> | Partial<FlipModifier> | Partial<PreventOverflowModifier> | Partial<PopperOffsetsModifier>;
+export declare type EventListeners = {
+    scroll: boolean;
+    resize: boolean;
+};
+export declare type Options = {
+    placement: Placement;
+    modifiers: Array<Partial<Modifier<any, any>>>;
+    strategy: PositioningStrategy;
+    onFirstUpdate?: (arg0: Partial<State>) => void;
+};
+export declare type OptionsGeneric<TModifier> = {
+    placement: Placement;
+    modifiers: Array<TModifier>;
+    strategy: PositioningStrategy;
+    onFirstUpdate?: (arg0: Partial<State>) => void;
+};
+export declare type UpdateCallback = (arg0: State) => void;
+export declare type ClientRectObject = {
+    x: number;
+    y: number;
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+};
+export declare type SideObject = {
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+};
+export declare type Padding = number | Partial<SideObject>;
+export declare type VirtualElement = {
+    getBoundingClientRect: () => ClientRect | DOMRect;
+    contextElement?: Element;
+};
+export {};

package/dist/ts3.9/_modules/@popperjs-core-lib-utils-detectOverflow.d.ts

@@ -0,0 +1,11 @@
+import type { State, SideObject, Padding } from "./@popperjs-core-lib-types";
+import type { Placement, Boundary, RootBoundary, Context } from "./@popperjs-core-lib-enums";
+export declare type Options = {
+    placement: Placement;
+    boundary: Boundary;
+    rootBoundary: RootBoundary;
+    elementContext: Context;
+    altBoundary: boolean;
+    padding: Padding;
+};
+export default function detectOverflow(state: State, options?: Partial<Options>): SideObject;