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

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

@@ -0,0 +1,193 @@
+import * as React from 'react';
+import type { CloseIconProps, IconProps } from './';
+declare const _default: {
+    argTypes: {
+        readonly type: {
+            readonly description: "Type represents 5 unique icon styles :- Solid, Regular, Light, Thin, Duotone";
+            readonly options: readonly ["regular", "solid", "duotone", "brands"];
+            readonly control: {
+                readonly type: "select";
+            };
+            readonly table: {
+                readonly type: {
+                    readonly summary: "string";
+                };
+                readonly defaultValue: {
+                    readonly summary: "regular";
+                };
+            };
+        };
+        readonly 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";
+                };
+            };
+        };
+        readonly color: {
+            readonly description: "Same set of colors as supported in text";
+            readonly options: unknown[];
+            readonly control: {
+                readonly type: "select";
+            };
+            readonly table: {
+                readonly type: {
+                    readonly summary: "string";
+                };
+                readonly defaultValue: {
+                    readonly summary: "primary";
+                };
+            };
+        };
+        readonly 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";
+                };
+            };
+        };
+        readonly swapOpacity: {
+            readonly name: "swapOpacity";
+            readonly description: "Swap the default opacity of each layer in a duotone icon.";
+            readonly options: readonly [false, true];
+            readonly control: "boolean";
+            readonly table: {
+                readonly type: {
+                    readonly summary: "boolean";
+                };
+                readonly defaultValue: {
+                    readonly summary: false;
+                };
+            };
+        };
+        readonly className: {
+            readonly description: "External className to be applied on container";
+            readonly control: {
+                readonly type: "text";
+            };
+            readonly table: {
+                readonly type: {
+                    readonly summary: "string";
+                };
+            };
+        };
+        readonly onClick: {
+            readonly description: "onClick handler";
+            readonly action: "clicked";
+            readonly table: {
+                readonly type: {
+                    readonly summary: "(SyntheticEvent<HTMLElement>) => mixed";
+                };
+            };
+        };
+        readonly disabled: {
+            readonly description: "If **true**, the clickable icon is disabled";
+            readonly control: {
+                readonly type: "boolean";
+            };
+            readonly table: {
+                readonly type: {
+                    readonly summary: "boolean";
+                };
+                readonly defaultValue: {
+                    readonly summary: "false";
+                };
+            };
+        };
+        readonly 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: {
+        readonly docs: {
+            readonly subtitle: "Generates a Icon component";
+            readonly description: {
+                readonly component: "\n```js\nimport {\n  Icon,\n  ClickableIcon,\n  CloseIcon,\n  SemanticIcon\n} from \"@spaced-out/ui-design-system/lib/components/Icon\";\n```\nIcon component uses <a href=\"https://fontawesome.com/icons\" target=\"_blank\">fontawesome</a> icon internally.\nThe name prop has be to consistent with one used in fontawesome.\n        ";
+            };
+        };
+        readonly storySource: {
+            readonly componentPath: "/src/components/Icon/Icon";
+        };
+    };
+    tags: string[];
+    title: string;
+    component: import("flow-to-typescript-codemod").Flow.AbstractComponent<IconProps, HTMLDivElement>;
+};
+export default _default;
+export declare const _Icon: {
+    (args: IconProps): React.JSX.Element;
+    args: {
+        type: string;
+        name: string;
+        size: string;
+        color: "primary";
+    };
+};
+export declare const _IconWithTooltip: {
+    (args: IconProps): React.JSX.Element;
+    args: {
+        type: string;
+        name: string;
+        size: string;
+        color: "primary";
+    };
+};
+export declare const _ClickableIcon: {
+    (args: IconProps): React.JSX.Element;
+    args: {
+        type: string;
+        name: string;
+        size: string;
+        color: "primary";
+        ariaLabel: string;
+    };
+};
+export declare const _CloseIcon: {
+    (args: CloseIconProps): React.JSX.Element;
+    args: {
+        type: string;
+        size: string;
+        color: "primary";
+        ariaLabel: string;
+    };
+};
+export declare const _DuotoneIcon: {
+    (args: IconProps): React.JSX.Element;
+    args: {
+        type: string;
+        name: string;
+        size: string;
+        color: "primary";
+        swapOpacity: boolean;
+        style: {
+            '--fa-primary-color': string;
+            '--fa-secondary-color': string;
+            '--fa-primary-opacity': string;
+            '--fa-secondary-opacity': string;
+        };
+    };
+};
+//# sourceMappingURL=Icon.stories.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Icon.stories.d.ts","sourceRoot":"","sources":["../../../src/components/Icon/Icon.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAS/B,OAAO,KAAK,EAAC,cAAc,EAAE,SAAS,EAAC,MAAM,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOlD,wBAKE;AAEF,eAAO,MAAM,KAAK;WAAU,SAAS;;;;;;;CAAuB,CAAC;AAS7D,eAAO,MAAM,gBAAgB;WAAU,SAAS;;;;;;;CAM/C,CAAC;AASF,eAAO,MAAM,cAAc;WAAU,SAAS;;;;;;;;CAE7C,CAAC;AAUF,eAAO,MAAM,UAAU;WAAU,cAAc;;;;;;;CAE9C,CAAC;AASF,eAAO,MAAM,YAAY;WAAU,SAAS;;;;;;;;;;;;;;CAAuB,CAAC"}

package/lib/components/Icon/SemanticIcon.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import type { AlertSemanticType } from '../../types/common';
+import type { IconProps } from './Icon';
+type ClassNames = Readonly<{
+    wrapper?: string;
+    icon?: string;
+}>;
+export type SemanticIconProps = IconProps & {
+    classNames?: ClassNames;
+    semantic?: AlertSemanticType;
+};
+export declare const SemanticIcon: ({ semantic, classNames, size, ...iconProps }: SemanticIconProps) => React.JSX.Element;
+export {};
+//# sourceMappingURL=SemanticIcon.d.ts.map

package/lib/components/Icon/SemanticIcon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SemanticIcon.d.ts","sourceRoot":"","sources":["../../../src/components/Icon/SemanticIcon.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAI1D,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,QAAQ,CAAC;AAMtC,KAAK,UAAU,GAAG,QAAQ,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG;IAC1C,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,8CAK1B,iBAAiB,sBAqBnB,CAAC"}

package/lib/components/Icon/SemanticIcon.js

@@ -22,7 +22,9 @@ const SemanticIcon = _ref => {
   return /*#__PURE__*/React.createElement(React.Fragment, null, !!iconProps.name && /*#__PURE__*/React.createElement("div", {
     className: (0, _classify.default)(_SemanticIconModule.default.iconContainer, _SemanticIconModule.default[semantic], _SemanticIconModule.default[size], classNames?.wrapper)
   }, /*#__PURE__*/React.createElement(_Icon.Icon, _extends({}, iconProps, {
-    className: (0, _classify.default)(iconProps.className, classNames?.icon),
+    className: (0, _classify.default)(iconProps.className, classNames?.icon)
+    // @ts-ignore - TS7053 - Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'Readonly<{ primary: string; secondary: string; tertiary: string; disabled: string; clickable: string; neutral: string; success: string; information: string; warning: string; danger: string; inversePrimary: string; inverseSecondary: string; favorite: string; }>'.
+    ,
     color: _typography.TEXT_COLORS[semantic],
     size: size === 'large' ? 'medium' : size
   }))));

package/lib/components/Icon/SemanticIcon.stories.d.ts

@@ -0,0 +1,190 @@
+import * as React from 'react';
+import type { SemanticIconProps } from './';
+declare const _default: {
+    argTypes: {
+        readonly semantic: {
+            readonly description: "The semantic type of the Icon Container (e.g., success, warning, danger, etc.).\n        This works only in case of `<SemanticIcon />`\n        ";
+            readonly control: {
+                readonly type: "select";
+            };
+            readonly options: unknown[];
+            readonly table: {
+                readonly type: {
+                    readonly summary: "AlertSemanticType";
+                };
+            };
+        };
+        readonly classNames: {
+            readonly description: "External classnames to be applied. Only valid in case of `<SemanticIcon />`. Use the className prop for `<Icon />`";
+            readonly control: {
+                readonly type: "object";
+            };
+            readonly table: {
+                readonly type: {
+                    readonly summary: "{wrapper?: string, icon?: string}";
+                };
+            };
+        };
+        readonly type: {
+            readonly description: "Type represents 5 unique icon styles :- Solid, Regular, Light, Thin, Duotone";
+            readonly options: readonly ["regular", "solid", "duotone", "brands"];
+            readonly control: {
+                readonly type: "select";
+            };
+            readonly table: {
+                readonly type: {
+                    readonly summary: "string";
+                };
+                readonly defaultValue: {
+                    readonly summary: "regular";
+                };
+            };
+        };
+        readonly 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";
+                };
+            };
+        };
+        readonly color: {
+            readonly description: "Same set of colors as supported in text";
+            readonly options: unknown[];
+            readonly control: {
+                readonly type: "select";
+            };
+            readonly table: {
+                readonly type: {
+                    readonly summary: "string";
+                };
+                readonly defaultValue: {
+                    readonly summary: "primary";
+                };
+            };
+        };
+        readonly 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";
+                };
+            };
+        };
+        readonly swapOpacity: {
+            readonly name: "swapOpacity";
+            readonly description: "Swap the default opacity of each layer in a duotone icon.";
+            readonly options: readonly [false, true];
+            readonly control: "boolean";
+            readonly table: {
+                readonly type: {
+                    readonly summary: "boolean";
+                };
+                readonly defaultValue: {
+                    readonly summary: false;
+                };
+            };
+        };
+        readonly className: {
+            readonly description: "External className to be applied on container";
+            readonly control: {
+                readonly type: "text";
+            };
+            readonly table: {
+                readonly type: {
+                    readonly summary: "string";
+                };
+            };
+        };
+        readonly onClick: {
+            readonly description: "onClick handler";
+            readonly action: "clicked";
+            readonly table: {
+                readonly type: {
+                    readonly summary: "(SyntheticEvent<HTMLElement>) => mixed";
+                };
+            };
+        };
+        readonly disabled: {
+            readonly description: "If **true**, the clickable icon is disabled";
+            readonly control: {
+                readonly type: "boolean";
+            };
+            readonly table: {
+                readonly type: {
+                    readonly summary: "boolean";
+                };
+                readonly defaultValue: {
+                    readonly summary: "false";
+                };
+            };
+        };
+        readonly 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: {
+        readonly docs: {
+            readonly subtitle: "Generates a Icon component";
+            readonly description: {
+                readonly component: "\n```js\nimport {\n  Icon,\n  ClickableIcon,\n  CloseIcon,\n  SemanticIcon\n} from \"@spaced-out/ui-design-system/lib/components/Icon\";\n```\nIcon component uses <a href=\"https://fontawesome.com/icons\" target=\"_blank\">fontawesome</a> icon internally.\nThe name prop has be to consistent with one used in fontawesome.\n        ";
+            };
+        };
+        readonly storySource: {
+            readonly componentPath: "/src/components/Icon/Icon";
+        };
+    };
+    tags: string[];
+    title: string;
+    component: ({ semantic, classNames, size, ...iconProps }: SemanticIconProps) => React.JSX.Element;
+};
+export default _default;
+/**
+ * The SemanticIcon component is a reusable
+ * React component that allows you to display
+ * icons with semantic styling based on different
+ * semantic types. It's designed to work with Font Awesome icons
+ * and can be used to maintain consistent icon styles across your
+ * application.
+ *
+ * Usage:
+ *
+ * ```jsx
+  <SemanticIcon
+    semantic="success"
+    iconName="chart-line-up"
+    iconSize="medium"
+    iconType="solid"
+    classNames={{ wrapper: css.wrapper, icon: css.icon }}
+  />
+ * ```
+ */
+export declare const _SemanticIcon: {
+    (args: SemanticIconProps): React.JSX.Element;
+    args: {
+        name: string;
+        semantic: string;
+    };
+};
+//# sourceMappingURL=SemanticIcon.stories.d.ts.map

package/lib/components/Icon/SemanticIcon.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SemanticIcon.stories.d.ts","sourceRoot":"","sources":["../../../src/components/Icon/SemanticIcon.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqC1C,wBAKE;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa;WAAU,iBAAiB;;;;;CAEpD,CAAC"}

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

@@ -0,0 +1,4 @@
+export * from './ClickableIcon';
+export * from './Icon';
+export * from './SemanticIcon';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Icon/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,QAAQ,CAAC;AACvB,cAAc,gBAAgB,CAAC"}

package/lib/components/InContextAlert/InContextAlert.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import type { Flow } from 'flow-to-typescript-codemod';
+import type { AlertSemanticType } from '../../types/common';
+import type { IconType } from '../Icon';
+type ClassNames = Readonly<{
+    wrapper?: string;
+    alertText?: string;
+    actionContainer?: string;
+    icon?: string;
+}>;
+type InContextAlertBaseProps = {
+    classNames?: ClassNames;
+} & ({
+    dismissable: true;
+    onCloseClick?: ((arg1: React.SyntheticEvent<HTMLElement>) => unknown) | null | undefined;
+    selfDismiss?: boolean;
+} | {
+    dismissable?: false;
+}) & {
+    children?: string;
+    actionText?: string;
+    onAction?: ((arg1: React.SyntheticEvent<HTMLElement>) => unknown) | null | undefined;
+};
+export type InContextAlertProps = InContextAlertBaseProps & {
+    semantic?: AlertSemanticType;
+    leftIconName?: string;
+    leftIconType?: IconType;
+};
+export declare const InContextAlert: Flow.AbstractComponent<InContextAlertProps, HTMLDivElement>;
+export {};
+//# sourceMappingURL=InContextAlert.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InContextAlert.d.ts","sourceRoot":"","sources":["../../../src/components/InContextAlert/InContextAlert.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,4BAA4B,CAAC;AAErD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAI1D,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,SAAS,CAAC;AAStC,KAAK,UAAU,GAAG,QAAQ,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC,CAAC;AAEH,KAAK,uBAAuB,GAAG;IAC7B,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,GAAG,CACA;IACE,WAAW,EAAE,IAAI,CAAC;IAClB,YAAY,CAAC,EACT,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,cAAc,CAAC,WAAW,CAAC,KAAK,OAAO,CAAC,GACtD,IAAI,GACJ,SAAS,CAAC;IACd,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GACD;IACE,WAAW,CAAC,EAAE,KAAK,CAAC;CACrB,CACJ,GAAG;IACA,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EACL,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,cAAc,CAAC,WAAW,CAAC,KAAK,OAAO,CAAC,GACtD,IAAI,GACJ,SAAS,CAAC;CACf,CAAC;AAEJ,MAAM,MAAM,mBAAmB,GAAG,uBAAuB,GAAG;IAC1D,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,QAAQ,CAAC;CACzB,CAAC;AAiFF,eAAO,MAAM,cAAc,EAAE,IAAI,CAAC,iBAAiB,CACjD,mBAAmB,EACnB,cAAc,CAmFf,CAAC"}

package/lib/components/InContextAlert/InContextAlert.js

@@ -79,8 +79,10 @@ const InContextAlert = exports.InContextAlert = /*#__PURE__*/React.forwardRef((p
     semantic = _common.ALERT_SEMANTIC.neutral,
     dismissable,
     children,
+    // @ts-ignore - TS2339 - Property 'selfDismiss' does not exist on type 'InContextAlertProps'.
     selfDismiss = false,
     leftIconName = '',
+    // @ts-ignore - TS2339 - Property 'onCloseClick' does not exist on type 'InContextAlertProps'.
     onCloseClick,
     actionText = '',
     onAction,

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

@@ -0,0 +1,164 @@
+import * as React from 'react';
+import type { InContextAlertProps } from './InContextAlert';
+declare const _default: {
+    tags: string[];
+    title: string;
+    argTypes: {
+        actionText: {
+            name: string;
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        onAction: {
+            name: string;
+            action: string;
+            description: string;
+            type: {
+                summary: string;
+            };
+        };
+        semantic: {
+            options: unknown[];
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: "neutral";
+                };
+            };
+        };
+        onCloseClick: {
+            name: string;
+            action: string;
+            description: string;
+            type: {
+                summary: string;
+            };
+        };
+        dismissable: {
+            description: string;
+            name: string;
+            options: boolean[];
+            control: string;
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: boolean;
+                };
+            };
+        };
+        selfDismiss: {
+            description: string;
+            name: string;
+            options: boolean[];
+            control: string;
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: boolean;
+                };
+            };
+        };
+        leftIconName: {
+            name: string;
+            control: {
+                type: string;
+            };
+            description: string;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        leftIconType: {
+            description: string;
+            options: string[];
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        children: {
+            description: string;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        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 _Default: {
+    (args: InContextAlertProps): React.JSX.Element;
+    args: {
+        children: string;
+        semantic: string;
+        leftIconName: string;
+    };
+};
+export declare const _Dismissable: {
+    (args: InContextAlertProps): React.JSX.Element;
+    args: {
+        children: string;
+        semantic: string;
+        dismissable: boolean;
+        selfDismiss: boolean;
+        leftIconName: string;
+    };
+};
+export declare const _Actionable: {
+    (args: InContextAlertProps): React.JSX.Element;
+    args: {
+        children: string;
+        semantic: string;
+        actionText: string;
+    };
+};
+//# sourceMappingURL=InContextAlert.stories.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InContextAlert.stories.d.ts","sourceRoot":"","sources":["../../../src/components/InContextAlert/InContextAlert.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQ1D,wBAqHE;AAEF,eAAO,MAAM,QAAQ;WAAU,mBAAmB;;;;;;CAIjD,CAAC;AASF,eAAO,MAAM,YAAY;WAAU,mBAAmB;;;;;;;;CAIrD,CAAC;AAWF,eAAO,MAAM,WAAW;WAAU,mBAAmB;;;;;;CAIpD,CAAC"}

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

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

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

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

package/lib/components/InfinitePagination/InfinitePagination.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import type { Flow } from 'flow-to-typescript-codemod';
+import type { GenericObject } from '../Table';
+type ClassNames = Readonly<{
+    wrapper?: string;
+}>;
+export type InfinitePaginationProps = {
+    items: Array<GenericObject>;
+    width: string;
+    threshold?: number;
+    classNames?: ClassNames;
+    renderItem: (item: GenericObject, index: number) => React.ReactNode;
+    getItemKey?: (item: GenericObject, index: number) => string | number;
+    hasNextPage: boolean;
+    loadMoreItems: () => Promise<void>;
+} & ({
+    itemSize: (index: number) => number;
+    isVariableSizeList: true;
+} | {
+    itemSize: number;
+    isVariableSizeList?: false;
+});
+export declare const InfinitePagination: Flow.AbstractComponent<InfinitePaginationProps, HTMLDivElement>;
+export {};
+//# sourceMappingURL=InfinitePagination.d.ts.map