@spaced-out/ui-design-system 0.4.15 → 0.5.1

package/lib/components/Avatar/Avatar.stories.d.ts

@@ -0,0 +1,149 @@
+import * as React from 'react';
+import type { AvatarProps } from './';
+declare const _default: {
+    tags: string[];
+    title: string;
+    argTypes: {
+        status: {
+            options: unknown[];
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        statusBorderColorToken: {
+            description: string;
+            options: unknown[];
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        imageSrc: {
+            description: string;
+        };
+        text: {
+            description: string;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        size: {
+            description: string;
+            control: {
+                type: string;
+            };
+            options: unknown[];
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        color: {
+            options: unknown[];
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        iconName: {
+            name: string;
+            description: string;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        iconType: {
+            description: string;
+            options: string[];
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        ring: {
+            description: string;
+            options: boolean[];
+            control: string;
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: boolean;
+                };
+            };
+        };
+        classNames: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+    };
+    parameters: {
+        docs: {
+            subtitle: string;
+            description: {
+                component: string;
+            };
+        };
+        storySource: {
+            componentPath: string;
+        };
+    };
+};
+export default _default;
+export declare const _Avatar: {
+    (args: AvatarProps): React.JSX.Element;
+    args: {
+        imageSrc: string;
+        size: "medium";
+        text: string;
+        iconName: string;
+        ring: boolean;
+        color: string;
+        iconType: string;
+    };
+};
+//# sourceMappingURL=Avatar.stories.d.ts.map

package/lib/components/Avatar/Avatar.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Avatar.stories.d.ts","sourceRoot":"","sources":["../../../src/components/Avatar/Avatar.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWpC,wBAoHE;AAEF,eAAO,MAAM,OAAO;WAAU,WAAW;;;;;;;;;;CAMxC,CAAC"}

package/lib/components/Avatar/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Avatar';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/Avatar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Avatar/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/lib/components/AvatarGroup/AvatarGroup.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { Flow } from 'flow-to-typescript-codemod';
+import type { AvatarSize } from '../Avatar';
+import type { ElevationType, PlacementType } from '../Tooltip';
+export type AvatarGroupProps = {
+    children?: React.ReactNode;
+    size?: AvatarSize;
+    borderColor?: string;
+    maxTooltipLines?: number;
+    placement?: PlacementType;
+    maxAvatars?: number;
+    tooltipElevation?: ElevationType;
+};
+export declare const AvatarGroup: Flow.AbstractComponent<AvatarGroupProps, HTMLDivElement>;
+//# sourceMappingURL=AvatarGroup.d.ts.map

package/lib/components/AvatarGroup/AvatarGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AvatarGroup.d.ts","sourceRoot":"","sources":["../../../src/components/AvatarGroup/AvatarGroup.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,4BAA4B,CAAC;AASrD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,WAAW,CAAC;AAE1C,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,YAAY,CAAC;AAQ7D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,aAAa,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,IAAI,CAAC,iBAAiB,CAC9C,gBAAgB,EAChB,cAAc,CAuIf,CAAC"}

package/lib/components/AvatarGroup/AvatarGroup.js

@@ -49,6 +49,7 @@ const AvatarGroup = exports.AvatarGroup = /*#__PURE__*/React.forwardRef((_ref, r
       },
       style: {
         borderColor,
+        // @ts-ignore - TS7053 - Element implicitly has an 'any' type because expression of type 'string' can't be used to index type '{ readonly small: "4px"; readonly medium: `${number}px`; readonly large: "8px"; readonly extraLarge: "12px"; }'.
         marginLeft: `-${index !== 0 ? leftOverlap[size] : 0}`
       },
       color
@@ -65,10 +66,12 @@ const AvatarGroup = exports.AvatarGroup = /*#__PURE__*/React.forwardRef((_ref, r
     const nameList = [];
     for (let i = maxAvatars - 1; i < totalAvatarCount; i++) {
       const child = childrenArray[i];
+      // @ts-ignore - TS2339 - Property 'props' does not exist on type 'string | number | bigint | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable<ReactNode> | ReactPortal | Promise<...>'.
       const {
         text
       } = child.props;
       if (text) {
+        // @ts-ignore - TS2345 - Argument of type 'any' is not assignable to parameter of type 'never'.
         nameList.push(text);
       }
     }
@@ -91,11 +94,13 @@ const AvatarGroup = exports.AvatarGroup = /*#__PURE__*/React.forwardRef((_ref, r
       },
       style: {
         borderColor,
+        // @ts-ignore - TS7053 - Element implicitly has an 'any' type because expression of type 'string' can't be used to index type '{ readonly small: "4px"; readonly medium: `${number}px`; readonly large: "8px"; readonly extraLarge: "12px"; }'.
         marginLeft: `-${leftOverlap[size]}`
       }
     })));
   };
   const childrenWithProps = React.Children.map(children, (child, index) => {
+    // @ts-ignore - TS2533 - Object is possibly 'null' or 'undefined'. | TS2339 - Property 'props' does not exist on type 'string | number | bigint | boolean | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable<ReactNode> | ReactPortal | Promise<...>'.
     const {
       imageSrc
     } = child.props;

package/lib/components/AvatarGroup/AvatarGroup.stories.d.ts

@@ -0,0 +1,101 @@
+import * as React from 'react';
+import type { AvatarGroupProps } from './';
+declare const _default: {
+    tags: string[];
+    title: string;
+    argTypes: {
+        size: {
+            description: string;
+            control: {
+                type: string;
+            };
+            options: unknown[];
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        maxTooltipLines: {
+            description: string;
+            control: {
+                type: string;
+                min: number;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: number;
+                };
+            };
+        };
+        maxAvatars: {
+            description: string;
+            control: {
+                type: string;
+                min: number;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: number;
+                };
+            };
+        };
+        borderColor: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        tooltipElevation: {
+            description: string;
+            control: {
+                type: string;
+            };
+            options: unknown[];
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+    };
+    parameters: {
+        docs: {
+            subtitle: string;
+            description: {
+                component: string;
+            };
+        };
+        storySource: {
+            componentPath: string;
+        };
+    };
+};
+export default _default;
+export declare const _AvatarGroup: {
+    (args: AvatarGroupProps): React.JSX.Element;
+    args: {
+        size: string;
+        maxTooltipLines: number;
+        maxAvatars: number;
+        borderColor: string;
+    };
+};
+//# sourceMappingURL=AvatarGroup.stories.d.ts.map

package/lib/components/AvatarGroup/AvatarGroup.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AvatarGroup.stories.d.ts","sourceRoot":"","sources":["../../../src/components/AvatarGroup/AvatarGroup.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQzC,wBA+EE;AAEF,eAAO,MAAM,YAAY;WAAU,gBAAgB;;;;;;;CAqClD,CAAC"}

package/lib/components/AvatarGroup/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AvatarGroup';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/AvatarGroup/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/AvatarGroup/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/lib/components/Badge/Badge.d.ts

@@ -0,0 +1,40 @@
+import * as React from 'react';
+import type { Flow } from 'flow-to-typescript-codemod';
+import type { IconSize, IconType } from '../Icon';
+type ClassNames = Readonly<{
+    wrapper?: string;
+    text?: string;
+    icon?: string;
+}>;
+export declare const BADGE_COLOR: Readonly<{
+    gray: "#EBEBEB";
+    red: "#fce8ed";
+    redDark: "#e31c4c";
+    orange: "#fcf2e7";
+    orangeDark: "#df7e0c";
+    green: "#e6f5ed";
+    greenDark: "#03964d";
+    blue: "#e6f0fe";
+    blueDark: "#0769f0";
+    indigo: "#f1f1f5";
+    indigoDark: "#706F9B";
+}>;
+export type BadgeColorType = keyof typeof BADGE_COLOR;
+export type BaseBadgeProps = {
+    classNames?: ClassNames;
+    fill?: BadgeColorType;
+};
+export type BadgeProps = BaseBadgeProps & {
+    text: string;
+};
+export type IconBadgeProps = BaseBadgeProps & {
+    iconName: string;
+    iconType?: IconType;
+    iconSize?: IconSize;
+    onClick?: ((arg1: React.SyntheticEvent<HTMLElement>) => unknown) | null | undefined;
+    ariaLabel?: string;
+};
+export declare const Badge: Flow.AbstractComponent<BadgeProps, HTMLDivElement>;
+export declare const IconBadge: Flow.AbstractComponent<IconBadgeProps, HTMLDivElement>;
+export {};
+//# sourceMappingURL=Badge.d.ts.map

package/lib/components/Badge/Badge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Badge.d.ts","sourceRoot":"","sources":["../../../src/components/Badge/Badge.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,4BAA4B,CAAC;AAgBrD,OAAO,KAAK,EAAC,QAAQ,EAAE,QAAQ,EAAC,MAAM,SAAS,CAAC;AAOhD,KAAK,UAAU,GAAG,QAAQ,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;EAYtB,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,WAAW,CAAC;AAEtD,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG;IACxC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,OAAO,CAAC,EACJ,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,cAAc,CAAC,WAAW,CAAC,KAAK,OAAO,CAAC,GACtD,IAAI,GACJ,SAAS,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,cAAc,CAkClE,CAAC;AAEJ,eAAO,MAAM,SAAS,EAAE,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,cAAc,CA8C1E,CAAC"}

package/lib/components/Badge/Badge.stories.d.ts

@@ -0,0 +1,123 @@
+import * as React from 'react';
+import type { BadgeProps, IconBadgeProps } from './Badge';
+declare const _default: {
+    tags: string[];
+    title: string;
+    argTypes: {
+        fill: {
+            description: string;
+            options: unknown[];
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        classNames: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        text: {
+            type: {
+                required: boolean;
+            };
+            description: string;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        iconName: {
+            description: string;
+            type: {
+                required: boolean;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        iconSize: {
+            description: string;
+            options: unknown[];
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        ariaLabel: {
+            control: {
+                type: string;
+            };
+            description: string;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        iconType: {
+            description: string;
+            options: string[];
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+    };
+    parameters: {
+        docs: {
+            subtitle: string;
+            description: {
+                component: string;
+            };
+        };
+        storySource: {
+            componentPath: string;
+        };
+    };
+};
+export default _default;
+export declare const _Badge: {
+    (args: BadgeProps): React.JSX.Element;
+    args: {
+        text: string;
+    };
+};
+export declare const _IconBadge: {
+    (args: IconBadgeProps): React.JSX.Element;
+    args: {
+        iconName: string;
+        fill: string;
+    };
+};
+//# sourceMappingURL=Badge.stories.d.ts.map

package/lib/components/Badge/Badge.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Badge.stories.d.ts","sourceRoot":"","sources":["../../../src/components/Badge/Badge.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,KAAK,EAAC,UAAU,EAAE,cAAc,EAAC,MAAM,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASxD,wBAmGE;AAEF,eAAO,MAAM,MAAM;WAAU,UAAU;;;;CAItC,CAAC;AAMF,eAAO,MAAM,UAAU;WAAU,cAAc;;;;;CAK9C,CAAC"}

package/lib/components/Badge/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Badge';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/Badge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Badge/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

package/lib/components/BadgedIcon/BadgedIcon.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import type { IconSize, IconType } from '../Icon';
+type ClassNames = Readonly<{
+    wrapper?: string;
+    icon?: string;
+    badgeIcon?: string;
+}>;
+export type BadgedIconProps = {
+    type?: IconType;
+    name: string;
+    size?: IconSize;
+    ariaLabel?: string;
+    showBadge?: boolean;
+    classNames?: ClassNames;
+};
+export declare const BadgedIcon: ({ name, showBadge, classNames, size, type, ariaLabel, }: BadgedIconProps) => React.JSX.Element;
+export {};
+//# sourceMappingURL=BadgedIcon.d.ts.map

package/lib/components/BadgedIcon/BadgedIcon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BadgedIcon.d.ts","sourceRoot":"","sources":["../../../src/components/BadgedIcon/BadgedIcon.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,KAAK,EAAC,QAAQ,EAAE,QAAQ,EAAC,MAAM,SAAS,CAAC;AAOhD,KAAK,UAAU,GAAG,QAAQ,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,yDAOxB,eAAe,sBAoBjB,CAAC"}

package/lib/components/BadgedIcon/BadgedIcon.js

@@ -26,7 +26,9 @@ const BadgedIcon = _ref => {
   }, /*#__PURE__*/React.createElement(_Icon.Icon, {
     ariaLabel: ariaLabel,
     name: name,
-    className: classNames?.icon,
+    className: classNames?.icon
+    // @ts-ignore - TS17001 - JSX elements cannot have multiple attributes with the same name.
+    ,
     name: name,
     size: size === 'large' ? 'medium' : size,
     type: type,

package/lib/components/BadgedIcon/BadgedIcon.stories.d.ts

@@ -0,0 +1,111 @@
+import * as React from 'react';
+import type { BadgedIconProps } from './';
+declare const _default: {
+    tags: string[];
+    title: string;
+    component: ({ name, showBadge, classNames, size, type, ariaLabel, }: BadgedIconProps) => React.JSX.Element;
+    argTypes: {
+        classNames: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        showBadge: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        type: {
+            description: string;
+            options: string[];
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        name: {
+            readonly description: "Icon Name represents name of icon as supported by fontawesome";
+            readonly type: {
+                readonly required: true;
+            };
+            readonly table: {
+                readonly type: {
+                    readonly summary: "string";
+                };
+                readonly defaultValue: {
+                    readonly summary: "face-party";
+                };
+            };
+        };
+        size: {
+            readonly description: "Icon supports three size variants namely small and medium. `small` < `medium` < `large`";
+            readonly options: unknown[];
+            readonly control: {
+                readonly type: "select";
+            };
+            readonly table: {
+                readonly type: {
+                    readonly summary: "string";
+                };
+                readonly defaultValue: {
+                    readonly summary: "medium";
+                };
+            };
+        };
+        ariaLabel: {
+            readonly control: {
+                readonly type: "text";
+            };
+            readonly description: "**aria-label** should be added where `ClickableIcon` and `CloseIcon` is used. This would avoid accessibility violations in screen readers";
+            readonly table: {
+                readonly type: {
+                    readonly summary: "string";
+                };
+            };
+        };
+    };
+    parameters: {
+        docs: {
+            subtitle: string;
+            description: {
+                component: string;
+            };
+        };
+        storySource: {
+            componentPath: string;
+        };
+    };
+};
+export default _default;
+export declare const _BadgedIcon: {
+    (args: BadgedIconProps): React.JSX.Element;
+    args: {
+        classNames: {
+            wrapper: string;
+        };
+        name: string;
+    };
+};
+//# sourceMappingURL=BadgedIcon.stories.d.ts.map

package/lib/components/BadgedIcon/BadgedIcon.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BadgedIcon.stories.d.ts","sourceRoot":"","sources":["../../../src/components/BadgedIcon/BadgedIcon.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQxC,wBA0DE;AAEF,eAAO,MAAM,WAAW;WAAU,eAAe;;;;;;;CAIhD,CAAC"}

package/lib/components/BadgedIcon/index.d.ts

@@ -0,0 +1,2 @@
+export * from './BadgedIcon';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/BadgedIcon/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/BadgedIcon/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/lib/components/Banner/Banner.d.ts

@@ -0,0 +1,7 @@
+import type { Flow } from 'flow-to-typescript-codemod';
+import type { InContextAlertProps } from '../InContextAlert';
+export type BannerProps = InContextAlertProps & {
+    alignment?: 'top' | 'bottom';
+};
+export declare const Banner: Flow.AbstractComponent<BannerProps, HTMLDivElement>;
+//# sourceMappingURL=Banner.d.ts.map

package/lib/components/Banner/Banner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Banner.d.ts","sourceRoot":"","sources":["../../../src/components/Banner/Banner.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,4BAA4B,CAAC;AAIrD,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AAM3D,MAAM,MAAM,WAAW,GAAG,mBAAmB,GAAG;IAC9C,SAAS,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,cAAc,CA0CpE,CAAC"}