@veracity/vui 0.0.8 → 0.0.10

package/system/borders.d.ts

@@ -1,133 +1,142 @@
-import { ITheme, SystemProp, VariantsType } from '@xstyled/system';
+import { SystemProp, VariantsType } from '@xstyled/system';
 import { ColorGetter } from './colors';
 import { VuiTheme } from '../theme';
-export declare type BorderGetter<T extends ITheme = VuiTheme> = VariantsType<T['borders']>;
-export declare type BorderStyleGetter<T extends ITheme = VuiTheme> = VariantsType<T['borderStyles']>;
-export declare type BorderWidthGetter<T extends ITheme = VuiTheme> = VariantsType<T['borderWidths']>;
-export declare type RadiusGetter<T extends ITheme = VuiTheme> = VariantsType<T['radii']>;
-export declare type RingWidthGetter<T extends ITheme = VuiTheme> = VariantsType<T['ringWidths']>;
-declare type BorderProp<T extends ITheme> = SystemProp<BorderGetter<T>, T>;
-export interface BorderProps<T extends ITheme = VuiTheme> {
-    border?: BorderProp<T>;
-    hoverBorder?: BorderProp<T>;
-}
-declare type BorderTopProp<T extends ITheme> = SystemProp<BorderGetter<T>, T>;
-export interface BorderTopProps<T extends ITheme = VuiTheme> {
-    borderTop?: BorderTopProp<T>;
-    hoverBorderTop?: BorderTopProp<T>;
-}
-declare type BorderRightProp<T extends ITheme> = SystemProp<BorderGetter<T>, T>;
-export interface BorderRightProps<T extends ITheme = VuiTheme> {
-    borderRight?: BorderRightProp<T>;
-    hoverBorderRight?: BorderRightProp<T>;
-}
-declare type BorderBottomProp<T extends ITheme> = SystemProp<BorderGetter<T>, T>;
-export interface BorderBottomProps<T extends ITheme = VuiTheme> {
-    borderBottom?: BorderBottomProp<T>;
-    hoverBorderBottom?: BorderBottomProp<T>;
-}
-declare type BorderLeftProp<T extends ITheme> = SystemProp<BorderGetter<T>, T>;
-export interface BorderLeftProps<T extends ITheme = VuiTheme> {
-    borderLeft?: BorderLeftProp<T>;
-    hoverBorderLeft?: BorderLeftProp<T>;
-}
-declare type BorderColorProp<T extends ITheme> = SystemProp<ColorGetter<T>, T>;
-export interface BorderColorProps<T extends ITheme = VuiTheme> {
-    borderColor?: BorderColorProp<T>;
-    disabledBorderColor?: BorderColorProp<T>;
-    focusBorderColor?: BorderColorProp<T>;
-    hoverBorderColor?: BorderColorProp<T>;
-    focusWithinBorderColor?: BorderColorProp<T>;
-}
-declare type BorderTopColorProp<T extends ITheme> = SystemProp<ColorGetter<T>, T>;
-export interface BorderTopColorProps<T extends ITheme = VuiTheme> {
-    borderTopColor?: BorderColorProp<T>;
-    hoverBorderTopColor?: BorderTopColorProp<T>;
-}
-declare type BorderRightColorProp<T extends ITheme> = SystemProp<ColorGetter<T>, T>;
-export interface BorderRightColorProps<T extends ITheme = VuiTheme> {
-    borderRightColor?: BorderColorProp<T>;
-    hoverBorderRightColor?: BorderRightColorProp<T>;
-}
-declare type BorderBottomColorProp<T extends ITheme> = SystemProp<ColorGetter<T>, T>;
-export interface BorderBottomColorProps<T extends ITheme = VuiTheme> {
-    borderBottomColor?: BorderColorProp<T>;
-    hoverBorderBottomColor?: BorderBottomColorProp<T>;
-}
-declare type BorderLeftColorProp<T extends ITheme> = SystemProp<ColorGetter<T>, T>;
-export interface BorderLeftColorProps<T extends ITheme = VuiTheme> {
-    borderLeftColor?: BorderColorProp<T>;
-    hoverBorderLeftColor?: BorderLeftColorProp<T>;
-}
-declare type BorderWidthProp<T extends ITheme> = SystemProp<BorderWidthGetter<T>, T>;
-export interface BorderWidthProps<T extends ITheme = VuiTheme> {
-    borderWidth?: BorderWidthProp<T>;
-    hoverBorderWidth?: BorderWidthProp<T>;
-}
-declare type BorderTopWidthProp<T extends ITheme> = SystemProp<BorderWidthGetter<T>, T>;
-export interface BorderTopWidthProps<T extends ITheme = VuiTheme> {
-    borderTopWidth?: BorderTopWidthProp<T>;
-    hoverBorderTopWidth?: BorderTopWidthProp<T>;
-}
-declare type BorderRightWidthProp<T extends ITheme> = SystemProp<BorderWidthGetter<T>, T>;
-export interface BorderRightWidthProps<T extends ITheme = VuiTheme> {
-    borderRightWidth?: BorderRightWidthProp<T>;
-    hoverBorderRightWidth?: BorderRightWidthProp<T>;
-}
-declare type BorderBottomWidthProp<T extends ITheme> = SystemProp<BorderWidthGetter<T>, T>;
-export interface BorderBottomWidthProps<T extends ITheme = VuiTheme> {
-    borderBottomWidth?: BorderBottomWidthProp<T>;
-    hoverBorderBottomWidth?: BorderBottomWidthProp<T>;
-}
-declare type BorderLeftWidthProp<T extends ITheme> = SystemProp<BorderWidthGetter<T>, T>;
-export interface BorderLeftWidthProps<T extends ITheme = VuiTheme> {
-    borderLeftWidth?: BorderLeftWidthProp<T>;
-    hoverBorderLeftWidth?: BorderLeftWidthProp<T>;
-}
-declare type BorderStyleProp<T extends ITheme> = SystemProp<BorderStyleGetter<T>, T>;
-export interface BorderStyleProps<T extends ITheme = VuiTheme> {
-    borderStyle?: BorderStyleProp<T>;
-    hoverBorderStyle?: BorderStyleProp<T>;
-}
-declare type BorderRadiusProp<T extends ITheme> = SystemProp<RadiusGetter<T>, T>;
-export interface BorderRadiusProps<T extends ITheme = VuiTheme> {
-    borderRadius?: BorderRadiusProp<T>;
-    hoverBorderRadius?: BorderRadiusProp<T>;
-}
-declare type OutlineProp<T extends ITheme> = SystemProp<BorderGetter<T>, T>;
-export interface OutlineProps<T extends ITheme = VuiTheme> {
-    outline?: OutlineProp<T>;
-    hoverOutline?: OutlineProp<T>;
-}
-declare type OutlineColorProp<T extends ITheme> = SystemProp<ColorGetter<T>, T>;
-export interface OutlineColorProps<T extends ITheme = VuiTheme> {
-    outlineColor?: OutlineColorProp<T>;
-    hoverOutlineColor?: OutlineColorProp<T>;
-}
-declare type OutlineWidthProp<T extends ITheme> = SystemProp<BorderWidthGetter<T>, T>;
-export interface OutlineWidthProps<T extends ITheme = VuiTheme> {
-    outlineWidth?: OutlineWidthProp<T>;
-    hoverOutlineWidth?: OutlineWidthProp<T>;
-}
-declare type OutlineStyleProp<T extends ITheme> = SystemProp<BorderStyleGetter<T>, T>;
-export interface OutlineStyleProps<T extends ITheme = VuiTheme> {
-    outlineStyle?: OutlineStyleProp<T>;
-    hoverOutlineStyle?: OutlineStyleProp<T>;
-}
-declare type RingProp<T extends ITheme> = SystemProp<RingWidthGetter<T>, T>;
-export interface RingProps<T extends ITheme = VuiTheme> {
-    ring?: RingProp<T>;
-    focusRing?: RingProp<T>;
-    focusVisibleRing?: RingProp<T>;
-    focusWithinRing?: RingProp<T>;
-}
-declare type RingColorProp<T extends ITheme> = SystemProp<ColorGetter<T>, T>;
-export interface RingColorProps<T extends ITheme = VuiTheme> {
-    ringColor?: RingColorProp<T>;
-    focusRingColor?: RingColorProp<T>;
-    focusVisibleRingColor?: RingColorProp<T>;
-    focusWithinRingColor?: RingColorProp<T>;
-}
-export interface BordersProps<T extends ITheme = VuiTheme> extends BorderProps<T>, BorderTopProps<T>, BorderRightProps<T>, BorderBottomProps<T>, BorderLeftProps<T>, BorderColorProps<T>, BorderTopColorProps<T>, BorderRightColorProps<T>, BorderBottomColorProps<T>, BorderLeftColorProps<T>, BorderWidthProps<T>, BorderTopWidthProps<T>, BorderRightWidthProps<T>, BorderBottomWidthProps<T>, BorderLeftWidthProps<T>, BorderStyleProps<T>, BorderRadiusProps<T>, OutlineProps<T>, OutlineColorProps<T>, OutlineWidthProps<T>, OutlineStyleProps<T>, RingProps<T>, RingColorProps<T> {
+export declare type BorderGetter = VariantsType<VuiTheme['borders']>;
+export declare type BorderStyleGetter = VariantsType<unknown>;
+export declare type BorderWidthGetter = VariantsType<unknown>;
+export declare type RadiusGetter = VariantsType<VuiTheme['radii']>;
+export declare type RingWidthGetter = VariantsType<VuiTheme['ringWidths']>;
+declare type BorderProp = SystemProp<BorderGetter, VuiTheme>;
+export interface BorderProps {
+    border?: BorderProp;
+    hoverBorder?: BorderProp;
+}
+declare type BorderTopProp = SystemProp<BorderGetter, VuiTheme>;
+export interface BorderTopProps {
+    borderTop?: BorderTopProp;
+}
+declare type BorderRightProp = SystemProp<BorderGetter, VuiTheme>;
+export interface BorderRightProps {
+    borderRight?: BorderRightProp;
+}
+declare type BorderBottomProp = SystemProp<BorderGetter, VuiTheme>;
+export interface BorderBottomProps {
+    borderBottom?: BorderBottomProp;
+}
+declare type BorderLeftProp = SystemProp<BorderGetter, VuiTheme>;
+export interface BorderLeftProps {
+    borderLeft?: BorderLeftProp;
+}
+declare type BorderColorProp = SystemProp<ColorGetter, VuiTheme>;
+export interface BorderColorProps {
+    borderColor?: BorderColorProp;
+    disabledBorderColor?: BorderColorProp;
+    focusBorderColor?: BorderColorProp;
+    hoverBorderColor?: BorderColorProp;
+    focusWithinBorderColor?: BorderColorProp;
+}
+declare type BorderTopColorProp = SystemProp<ColorGetter, VuiTheme>;
+export interface BorderTopColorProps {
+    borderTopColor?: BorderTopColorProp;
+}
+declare type BorderRightColorProp = SystemProp<ColorGetter, VuiTheme>;
+export interface BorderRightColorProps {
+    borderRightColor?: BorderRightColorProp;
+}
+declare type BorderBottomColorProp = SystemProp<ColorGetter, VuiTheme>;
+export interface BorderBottomColorProps {
+    borderBottomColor?: BorderBottomColorProp;
+}
+declare type BorderLeftColorProp = SystemProp<ColorGetter, VuiTheme>;
+export interface BorderLeftColorProps {
+    borderLeftColor?: BorderLeftColorProp;
+}
+declare type BorderWidthProp = SystemProp<BorderWidthGetter, VuiTheme>;
+export interface BorderWidthProps {
+    borderWidth?: BorderWidthProp;
+    hoverBorderWidth?: BorderWidthProp;
+}
+declare type BorderTopWidthProp = SystemProp<BorderWidthGetter, VuiTheme>;
+export interface BorderTopWidthProps {
+    borderTopWidth?: BorderTopWidthProp;
+}
+declare type BorderRightWidthProp = SystemProp<BorderWidthGetter, VuiTheme>;
+export interface BorderRightWidthProps {
+    borderRightWidth?: BorderRightWidthProp;
+}
+declare type BorderBottomWidthProp = SystemProp<BorderWidthGetter, VuiTheme>;
+export interface BorderBottomWidthProps {
+    borderBottomWidth?: BorderBottomWidthProp;
+}
+declare type BorderLeftWidthProp = SystemProp<BorderWidthGetter, VuiTheme>;
+export interface BorderLeftWidthProps {
+    borderLeftWidth?: BorderLeftWidthProp;
+}
+declare type BorderStyleProp = SystemProp<BorderStyleGetter, VuiTheme>;
+export interface BorderStyleProps {
+    borderStyle?: BorderStyleProp;
+    hoverBorderStyle?: BorderStyleProp;
+}
+declare type BorderRadiusProp = SystemProp<RadiusGetter, VuiTheme>;
+export interface BorderRadiusProps {
+    borderRadius?: BorderRadiusProp;
+    hoverBorderRadius?: BorderRadiusProp;
+}
+declare type OutlineProp = SystemProp<BorderGetter, VuiTheme>;
+export interface OutlineProps {
+    outline?: OutlineProp;
+}
+declare type OutlineColorProp = SystemProp<ColorGetter, VuiTheme>;
+export interface OutlineColorProps {
+    outlineColor?: OutlineColorProp;
+}
+declare type OutlineWidthProp = SystemProp<BorderWidthGetter, VuiTheme>;
+export interface OutlineWidthProps {
+    outlineWidth?: OutlineWidthProp;
+}
+declare type OutlineStyleProp = SystemProp<BorderStyleGetter, VuiTheme>;
+export interface OutlineStyleProps {
+    outlineStyle?: OutlineStyleProp;
+}
+declare type DivideXProp = SystemProp<BorderWidthGetter, VuiTheme>;
+export interface DivideXProps {
+    divideX?: DivideXProp;
+}
+declare type DivideYProp = SystemProp<BorderWidthGetter, VuiTheme>;
+export interface DivideYProps {
+    divideY?: DivideYProp;
+}
+declare type DivideXReverseProp = SystemProp<BorderWidthGetter, VuiTheme>;
+export interface DivideXReverseProps {
+    divideXReverse?: DivideXReverseProp;
+}
+declare type DivideYReverseProp = SystemProp<BorderWidthGetter, VuiTheme>;
+export interface DivideYReverseProps {
+    divideYReverse?: DivideYReverseProp;
+}
+declare type DivideColorProp = SystemProp<ColorGetter, VuiTheme>;
+export interface DivideColorProps {
+    divideColor?: DivideColorProp;
+    hoverDivideColor?: DivideColorProp;
+}
+declare type DivideStyleProp = SystemProp<BorderStyleGetter, VuiTheme>;
+export interface DivideStyleProps {
+    divideStyle?: DivideStyleProp;
+}
+declare type RingProp = SystemProp<RingWidthGetter, VuiTheme>;
+export interface RingProps {
+    ring?: RingProp;
+    focusRing?: RingProp;
+    focusVisibleRing?: RingProp;
+    focusWithinRing?: RingProp;
+}
+declare type RingColorProp = SystemProp<ColorGetter, VuiTheme>;
+export interface RingColorProps {
+    ringColor?: RingColorProp;
+    focusRingColor?: RingColorProp;
+    focusVisibleRingColor?: RingColorProp;
+    focusWithinRingColor?: RingColorProp;
+}
+export interface BordersProps extends BorderProps, BorderTopProps, BorderRightProps, BorderBottomProps, BorderLeftProps, BorderColorProps, BorderTopColorProps, BorderRightColorProps, BorderBottomColorProps, BorderLeftColorProps, BorderWidthProps, BorderTopWidthProps, BorderRightWidthProps, BorderBottomWidthProps, BorderLeftWidthProps, BorderStyleProps, BorderRadiusProps, OutlineProps, OutlineColorProps, OutlineWidthProps, OutlineStyleProps, DivideXProps, DivideYProps, DivideXReverseProps, DivideYReverseProps, DivideColorProps, DivideStyleProps, RingProps, RingColorProps {
 }
 export {};

package/system/colors.d.ts

@@ -1,4 +1,3 @@
-import { ITheme } from '@xstyled/system';
 import { VuiTheme } from '../theme';
 import { AnyString } from '../utils';
-export declare type ColorGetter<T extends ITheme = VuiTheme> = keyof T['colors'] | AnyString;
+export declare type ColorGetter = keyof VuiTheme['colors'] | AnyString;

package/system/effects.d.ts

@@ -1,18 +1,21 @@
-import { ITheme, SystemProp, VariantsType } from '@xstyled/system';
+import { SystemProp, VariantsType } from '@xstyled/system';
 import * as CSS from 'csstype';
 import { VuiTheme } from '../theme';
-export declare type ShadowGetter<T extends ITheme = VuiTheme> = VariantsType<T['shadows']>;
-declare type OpacityProp<T extends ITheme> = SystemProp<CSS.Property.Opacity, T>;
-export interface OpacityProps<T extends ITheme = VuiTheme> {
-    opacity?: OpacityProp<T>;
-    hoverOpacity?: OpacityProp<T>;
+export declare type ShadowGetter = VariantsType<VuiTheme['shadows']>;
+declare type OpacityProp = SystemProp<CSS.Property.Opacity, VuiTheme>;
+export interface OpacityProps {
+    opacity?: OpacityProp;
+    hoverOpacity?: OpacityProp;
 }
-declare type BoxShadowProp<T extends ITheme> = SystemProp<ShadowGetter<T>, T>;
-export interface BoxShadowProps<T extends ITheme = VuiTheme> {
-    boxShadow?: BoxShadowProp<T>;
-    focusBoxShadow?: BoxShadowProp<T>;
-    hoverBoxShadow?: BoxShadowProp<T>;
+declare type BoxShadowProp = SystemProp<ShadowGetter, VuiTheme>;
+export interface BoxShadowProps {
+    boxShadow?: BoxShadowProp;
+    hoverBoxShadow?: BoxShadowProp;
 }
-export interface EffectsProps<T extends ITheme = VuiTheme> extends OpacityProps<T>, BoxShadowProps<T> {
+declare type TextShadowProp = SystemProp<ShadowGetter, VuiTheme>;
+export interface TextShadowProps {
+    textShadow?: TextShadowProp;
+}
+export interface EffectsProps extends OpacityProps, BoxShadowProps, TextShadowProps {
 }
 export {};

package/system/flexboxes.d.ts

@@ -1,72 +1,61 @@
-import { ITheme, SystemProp } from '@xstyled/system';
+import { SystemProp } from '@xstyled/system';
 import * as CSS from 'csstype';
 import { DisplayProps } from './layout';
 import { VuiTheme } from '../theme';
-declare type AlignItemsProp<T extends ITheme> = SystemProp<CSS.Property.AlignItems, T>;
-export interface AlignItemsProps<T extends ITheme = VuiTheme> {
-    alignItems?: AlignItemsProp<T>;
-    hoverAlignItems?: AlignItemsProp<T>;
+declare type AlignItemsProp = SystemProp<CSS.Property.AlignItems, VuiTheme>;
+export interface AlignItemsProps {
+    alignItems?: AlignItemsProp;
 }
-declare type AlignContentProp<T extends ITheme> = SystemProp<CSS.Property.AlignContent, T>;
-export interface AlignContentProps<T extends ITheme = VuiTheme> {
-    alignContent?: AlignContentProp<T>;
-    hoverAlignContent?: AlignContentProp<T>;
+declare type AlignContentProp = SystemProp<CSS.Property.AlignContent, VuiTheme>;
+export interface AlignContentProps {
+    alignContent?: AlignContentProp;
 }
-declare type JustifyContentProp<T extends ITheme> = SystemProp<CSS.Property.JustifyContent, T>;
-export interface JustifyContentProps<T extends ITheme = VuiTheme> {
-    justifyContent?: JustifyContentProp<T>;
-    hoverJustifyContent?: JustifyContentProp<T>;
+declare type JustifyContentProp = SystemProp<CSS.Property.JustifyContent, VuiTheme>;
+export interface JustifyContentProps {
+    justifyContent?: JustifyContentProp;
 }
-declare type JustifyItemsProp<T extends ITheme> = SystemProp<CSS.Property.JustifyItems, T>;
-export interface JustifyItemsProps<T extends ITheme = VuiTheme> {
-    justifyItems?: JustifyItemsProp<T>;
-    hoverJustifyItems?: JustifyItemsProp<T>;
+declare type JustifyItemsProp = SystemProp<CSS.Property.JustifyItems, VuiTheme>;
+export interface JustifyItemsProps {
+    justifyItems?: JustifyItemsProp;
 }
-declare type FlexWrapProp<T extends ITheme> = SystemProp<CSS.Property.FlexWrap, T>;
-export interface FlexWrapProps<T extends ITheme = VuiTheme> {
-    flexWrap?: FlexWrapProp<T>;
-    hoverFlexWrap?: FlexWrapProp<T>;
+declare type FlexWrapProp = SystemProp<CSS.Property.FlexWrap, VuiTheme>;
+export interface FlexWrapProps {
+    flexWrap?: FlexWrapProp;
 }
-declare type FlexGrowProp<T extends ITheme> = SystemProp<CSS.Property.FlexGrow, T>;
-export interface FlexGrowProps<T extends ITheme = VuiTheme> {
-    flexGrow?: FlexGrowProp<T>;
-    hoverFlexGrow?: FlexGrowProp<T>;
+declare type FlexGrowProp = SystemProp<CSS.Property.FlexGrow, VuiTheme>;
+export interface FlexGrowProps {
+    flexGrow?: FlexGrowProp;
 }
-declare type FlexShrinkProp<T extends ITheme> = SystemProp<CSS.Property.FlexShrink, T>;
-export interface FlexShrinkProps<T extends ITheme = VuiTheme> {
-    flexShrink?: FlexShrinkProp<T>;
-    hoverFlexShrink?: FlexShrinkProp<T>;
+declare type FlexShrinkProp = SystemProp<CSS.Property.FlexShrink, VuiTheme>;
+export interface FlexShrinkProps {
+    flexShrink?: FlexShrinkProp;
 }
-declare type FlexBasisProp<T extends ITheme> = SystemProp<CSS.Property.FlexBasis, T>;
-export interface FlexBasisProps<T extends ITheme = VuiTheme> {
-    flexBasis?: FlexBasisProp<T>;
-    hoverFlexBasis?: FlexBasisProp<T>;
+declare type FlexBasisProp = SystemProp<CSS.Property.FlexBasis, VuiTheme>;
+export interface FlexBasisProps {
+    flexBasis?: FlexBasisProp;
+    hoverFlexBasis?: FlexBasisProp;
 }
-declare type FlexDirectionProp<T extends ITheme> = SystemProp<CSS.Property.FlexDirection, T>;
-export interface FlexDirectionProps<T extends ITheme = VuiTheme> {
-    flexDirection?: FlexDirectionProp<T>;
-    hoverFlexDirection?: FlexDirectionProp<T>;
+declare type FlexDirectionProp = SystemProp<CSS.Property.FlexDirection, VuiTheme>;
+export interface FlexDirectionProps {
+    flexDirection?: FlexDirectionProp;
 }
-declare type FlexProp<T extends ITheme> = SystemProp<CSS.Property.Flex, T>;
-export interface FlexProps<T extends ITheme = VuiTheme> {
-    flex?: FlexProp<T>;
-    hoverFlex?: FlexProp<T>;
+declare type FlexProp = SystemProp<CSS.Property.Flex, VuiTheme>;
+export interface FlexProps {
+    flex?: FlexProp;
+    hoverFlex?: FlexProp;
 }
-declare type JustifySelfProp<T extends ITheme> = SystemProp<CSS.Property.JustifySelf, T>;
-export interface JustifySelfProps<T extends ITheme = VuiTheme> {
-    justifySelf?: JustifySelfProp<T>;
-    hoverJustifySelf?: JustifySelfProp<T>;
+declare type JustifySelfProp = SystemProp<CSS.Property.JustifySelf, VuiTheme>;
+export interface JustifySelfProps {
+    justifySelf?: JustifySelfProp;
 }
-declare type AlignSelfProp<T extends ITheme> = SystemProp<CSS.Property.AlignSelf, T>;
-export interface AlignSelfProps<T extends ITheme = VuiTheme> {
-    alignSelf?: AlignSelfProp<T>;
-    hoverAlignSelf?: AlignSelfProp<T>;
+declare type AlignSelfProp = SystemProp<CSS.Property.AlignSelf, VuiTheme>;
+export interface AlignSelfProps {
+    alignSelf?: AlignSelfProp;
 }
-declare type OrderProp<T extends ITheme> = SystemProp<CSS.Property.Order, T>;
-export interface OrderProps<T extends ITheme = VuiTheme> {
-    order?: OrderProp<T>;
-    hoverOrder?: OrderProp<T>;
+declare type OrderProp = SystemProp<CSS.Property.Order, VuiTheme>;
+export interface OrderProps {
+    order?: OrderProp;
 }
-export interface FlexboxesProps<T extends ITheme = VuiTheme> extends DisplayProps<T>, AlignItemsProps<T>, AlignContentProps<T>, JustifyContentProps<T>, JustifyItemsProps<T>, FlexWrapProps<T>, FlexGrowProps<T>, FlexShrinkProps<T>, FlexBasisProps<T>, FlexDirectionProps<T>, FlexProps<T>, JustifySelfProps<T>, AlignSelfProps<T>, OrderProps<T> {
+export interface FlexboxesProps extends DisplayProps, AlignItemsProps, AlignContentProps, JustifyContentProps, JustifyItemsProps, FlexWrapProps, FlexGrowProps, FlexShrinkProps, FlexBasisProps, FlexDirectionProps, FlexProps, JustifySelfProps, AlignSelfProps, OrderProps {
 }
 export {};

package/system/index.d.ts

@@ -9,6 +9,8 @@ export * from './interactivity';
 export * from './layout';
 export * from './sizing';
 export * from './space';
+export * from './system';
 export * from './transforms';
 export * from './transitions';
 export * from './typography';
+export { default as system } from './system';

package/system/index.js

@@ -9,7 +9,11 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.system = void 0;
 __exportStar(require("./animations"), exports);
 __exportStar(require("./backgrounds"), exports);
 __exportStar(require("./borders"), exports);
@@ -21,6 +25,9 @@ __exportStar(require("./interactivity"), exports);
 __exportStar(require("./layout"), exports);
 __exportStar(require("./sizing"), exports);
 __exportStar(require("./space"), exports);
+__exportStar(require("./system"), exports);
 __exportStar(require("./transforms"), exports);
 __exportStar(require("./transitions"), exports);
 __exportStar(require("./typography"), exports);
+var system_1 = require("./system");
+Object.defineProperty(exports, "system", { enumerable: true, get: function () { return __importDefault(system_1).default; } });

package/system/interactivity.d.ts

@@ -1,32 +1,26 @@
-import { ITheme, SystemProp } from '@xstyled/system';
+import { SystemProp } from '@xstyled/system';
 import * as CSS from 'csstype';
 import { VuiTheme } from '../theme';
-declare type AppearanceProp<T extends ITheme> = SystemProp<CSS.Property.Appearance, T>;
-export interface AppearanceProps<T extends ITheme = VuiTheme> {
-    appearance?: AppearanceProp<T>;
-    hoverAppearance?: AppearanceProp<T>;
+declare type AppearanceProp = SystemProp<CSS.Property.Appearance, VuiTheme>;
+export interface AppearanceProps {
+    appearance?: AppearanceProp;
 }
-declare type CursorProp<T extends ITheme> = SystemProp<CSS.Property.Cursor, T>;
-export interface CursorProps<T extends ITheme = VuiTheme> {
-    cursor?: CursorProp<T>;
-    hoverCursor?: CursorProp<T>;
+declare type CursorProp = SystemProp<CSS.Property.Cursor, VuiTheme>;
+export interface CursorProps {
+    cursor?: CursorProp;
 }
-declare type PointerEventsProp<T extends ITheme> = SystemProp<CSS.Property.PointerEvents, T>;
-export interface PointerEventsProps<T extends ITheme = VuiTheme> {
-    pointerEvents?: PointerEventsProp<T>;
-    disabledPointerEvents?: PointerEventsProp<T>;
-    hoverPointerEvents?: PointerEventsProp<T>;
+declare type PointerEventsProp = SystemProp<CSS.Property.PointerEvents, VuiTheme>;
+export interface PointerEventsProps {
+    pointerEvents?: PointerEventsProp;
 }
-declare type ResizeProp<T extends ITheme> = SystemProp<CSS.Property.Resize, T>;
-export interface ResizeProps<T extends ITheme = VuiTheme> {
-    resize?: ResizeProp<T>;
-    hoverResize?: ResizeProp<T>;
+declare type ResizeProp = SystemProp<CSS.Property.Resize, VuiTheme>;
+export interface ResizeProps {
+    resize?: ResizeProp;
 }
-declare type UserSelectProp<T extends ITheme> = SystemProp<CSS.Property.UserSelect, T>;
-export interface UserSelectProps<T extends ITheme = VuiTheme> {
-    userSelect?: UserSelectProp<T>;
-    hoverUserSelect?: UserSelectProp<T>;
+declare type UserSelectProp = SystemProp<CSS.Property.UserSelect, VuiTheme>;
+export interface UserSelectProps {
+    userSelect?: UserSelectProp;
 }
-export interface InteractivityProps<T extends ITheme = VuiTheme> extends AppearanceProps<T>, CursorProps<T>, PointerEventsProps<T>, ResizeProps<T>, UserSelectProps<T> {
+export interface InteractivityProps extends AppearanceProps, CursorProps, PointerEventsProps, ResizeProps, UserSelectProps {
 }
 export {};