@veracity/vui 0.0.1

package/system/borders.d.ts

@@ -0,0 +1,133 @@
+import { ITheme, 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 {};

package/system/borders.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/system/colors.d.ts

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

package/system/colors.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/system/custom.d.ts

@@ -0,0 +1,10 @@
+/** Provides styling to truncate multi-line text. */
+export declare const maxLines: import("@xstyled/system").StyleGenerator;
+export interface MaxLinesProps {
+    maxLines?: number;
+}
+/** Provides styling to truncate single-line text. */
+export declare const isTruncated: import("@xstyled/system").StyleGenerator;
+export interface IsTruncatedProps {
+    isTruncated?: boolean;
+}

package/system/custom.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTruncated = exports.maxLines = void 0;
+var system_1 = require("@xstyled/system");
+/** Provides styling to truncate multi-line text. */
+exports.maxLines = system_1.style({
+    prop: 'maxLines',
+    cssProperty: function (value) {
+        return {
+            display: '-webkit-box',
+            overflow: 'hidden',
+            '-webkit-line-clamp': "" + value,
+            '-webkit-box-orient': 'vertical'
+        };
+    },
+    states: {}
+});
+/** Provides styling to truncate single-line text. */
+exports.isTruncated = system_1.style({
+    prop: 'isTruncated',
+    cssProperty: function () {
+        return {
+            overflow: 'hidden',
+            'text-overflow': 'ellipsis',
+            'white-space': 'nowrap'
+        };
+    },
+    states: {}
+});

package/system/effects.d.ts

@@ -0,0 +1,18 @@
+import { ITheme, 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>;
+}
+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>;
+}
+export interface EffectsProps<T extends ITheme = VuiTheme> extends OpacityProps<T>, BoxShadowProps<T> {
+}
+export {};

package/system/effects.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/system/flexboxes.d.ts

@@ -0,0 +1,72 @@
+import { ITheme, 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 AlignContentProp<T extends ITheme> = SystemProp<CSS.Property.AlignContent, T>;
+export interface AlignContentProps<T extends ITheme = VuiTheme> {
+    alignContent?: AlignContentProp<T>;
+    hoverAlignContent?: AlignContentProp<T>;
+}
+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 JustifyItemsProp<T extends ITheme> = SystemProp<CSS.Property.JustifyItems, T>;
+export interface JustifyItemsProps<T extends ITheme = VuiTheme> {
+    justifyItems?: JustifyItemsProp<T>;
+    hoverJustifyItems?: JustifyItemsProp<T>;
+}
+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 FlexGrowProp<T extends ITheme> = SystemProp<CSS.Property.FlexGrow, T>;
+export interface FlexGrowProps<T extends ITheme = VuiTheme> {
+    flexGrow?: FlexGrowProp<T>;
+    hoverFlexGrow?: FlexGrowProp<T>;
+}
+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 FlexBasisProp<T extends ITheme> = SystemProp<CSS.Property.FlexBasis, T>;
+export interface FlexBasisProps<T extends ITheme = VuiTheme> {
+    flexBasis?: FlexBasisProp<T>;
+    hoverFlexBasis?: FlexBasisProp<T>;
+}
+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 FlexProp<T extends ITheme> = SystemProp<CSS.Property.Flex, T>;
+export interface FlexProps<T extends ITheme = VuiTheme> {
+    flex?: FlexProp<T>;
+    hoverFlex?: FlexProp<T>;
+}
+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 AlignSelfProp<T extends ITheme> = SystemProp<CSS.Property.AlignSelf, T>;
+export interface AlignSelfProps<T extends ITheme = VuiTheme> {
+    alignSelf?: AlignSelfProp<T>;
+    hoverAlignSelf?: AlignSelfProp<T>;
+}
+declare type OrderProp<T extends ITheme> = SystemProp<CSS.Property.Order, T>;
+export interface OrderProps<T extends ITheme = VuiTheme> {
+    order?: OrderProp<T>;
+    hoverOrder?: OrderProp<T>;
+}
+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 {};

package/system/flexboxes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/system/index.d.ts

@@ -0,0 +1,14 @@
+export * from './animations';
+export * from './backgrounds';
+export * from './borders';
+export * from './colors';
+export * from './custom';
+export * from './effects';
+export * from './flexboxes';
+export * from './interactivity';
+export * from './layout';
+export * from './sizing';
+export * from './space';
+export * from './transforms';
+export * from './transitions';
+export * from './typography';

package/system/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./animations"), exports);
+__exportStar(require("./backgrounds"), exports);
+__exportStar(require("./borders"), exports);
+__exportStar(require("./colors"), exports);
+__exportStar(require("./custom"), exports);
+__exportStar(require("./effects"), exports);
+__exportStar(require("./flexboxes"), exports);
+__exportStar(require("./interactivity"), exports);
+__exportStar(require("./layout"), exports);
+__exportStar(require("./sizing"), exports);
+__exportStar(require("./space"), exports);
+__exportStar(require("./transforms"), exports);
+__exportStar(require("./transitions"), exports);
+__exportStar(require("./typography"), exports);

package/system/interactivity.d.ts

@@ -0,0 +1,32 @@
+import { ITheme, 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 CursorProp<T extends ITheme> = SystemProp<CSS.Property.Cursor, T>;
+export interface CursorProps<T extends ITheme = VuiTheme> {
+    cursor?: CursorProp<T>;
+    hoverCursor?: CursorProp<T>;
+}
+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 ResizeProp<T extends ITheme> = SystemProp<CSS.Property.Resize, T>;
+export interface ResizeProps<T extends ITheme = VuiTheme> {
+    resize?: ResizeProp<T>;
+    hoverResize?: ResizeProp<T>;
+}
+declare type UserSelectProp<T extends ITheme> = SystemProp<CSS.Property.UserSelect, T>;
+export interface UserSelectProps<T extends ITheme = VuiTheme> {
+    userSelect?: UserSelectProp<T>;
+    hoverUserSelect?: UserSelectProp<T>;
+}
+export interface InteractivityProps<T extends ITheme = VuiTheme> extends AppearanceProps<T>, CursorProps<T>, PointerEventsProps<T>, ResizeProps<T>, UserSelectProps<T> {
+}
+export {};

package/system/interactivity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/system/layout.d.ts

@@ -0,0 +1,78 @@
+import { ITheme, SystemProp, VariantsType } from '@xstyled/system';
+import * as CSS from 'csstype';
+import { VuiTheme } from '../theme';
+export declare type InsetGetter<T extends ITheme = VuiTheme> = VariantsType<T['inset']>;
+export declare type ZIndexGetter<T extends ITheme = VuiTheme> = VariantsType<T['zIndices']>;
+declare type DisplayProp<T extends ITheme> = SystemProp<CSS.Property.Display, T>;
+export interface DisplayProps<T extends ITheme = VuiTheme> {
+    display?: DisplayProp<T>;
+    hoverDisplay?: DisplayProp<T>;
+}
+declare type FloatProp<T extends ITheme> = SystemProp<CSS.Property.Float, T>;
+export interface FloatProps<T extends ITheme = VuiTheme> {
+    float?: FloatProp<T>;
+    hoverFloat?: FloatProp<T>;
+}
+declare type BoxSizingProp<T extends ITheme> = SystemProp<CSS.Property.BoxSizing, T>;
+export interface BoxSizingProps<T extends ITheme = VuiTheme> {
+    boxSizing?: BoxSizingProp<T>;
+    hoverBoxSizing?: BoxSizingProp<T>;
+}
+declare type OverflowProp<T extends ITheme> = SystemProp<CSS.Property.Overflow, T>;
+export interface OverflowProps<T extends ITheme = VuiTheme> {
+    overflow?: OverflowProp<T>;
+    hoverOverflow?: OverflowProp<T>;
+}
+declare type OverflowXProp<T extends ITheme> = SystemProp<CSS.Property.OverflowX, T>;
+export interface OverflowXProps<T extends ITheme = VuiTheme> {
+    overflowX?: OverflowXProp<T>;
+    hoverOverflowX?: OverflowXProp<T>;
+}
+declare type OverflowYProp<T extends ITheme> = SystemProp<CSS.Property.OverflowY, T>;
+export interface OverflowYProps<T extends ITheme = VuiTheme> {
+    overflowY?: OverflowYProp<T>;
+    hoverOverflowY?: OverflowYProp<T>;
+}
+declare type ZIndexProp<T extends ITheme> = SystemProp<ZIndexGetter<T> | CSS.Property.ZIndex, T>;
+export interface ZIndexProps<T extends ITheme = VuiTheme> {
+    zIndex?: ZIndexProp<T>;
+    hoverZIndex?: ZIndexProp<T>;
+}
+declare type PositionProp<T extends ITheme> = SystemProp<CSS.Property.Position, T>;
+export interface PositionProps<T extends ITheme = VuiTheme> {
+    position?: PositionProp<T>;
+    hoverPosition?: PositionProp<T>;
+}
+declare type TopProp<T extends ITheme> = SystemProp<InsetGetter<T> | CSS.Property.Top, T>;
+export interface TopProps<T extends ITheme = VuiTheme> {
+    top?: TopProp<T>;
+    hoverTop?: TopProp<T>;
+}
+declare type RightProp<T extends ITheme> = SystemProp<InsetGetter<T> | CSS.Property.Right, T>;
+export interface RightProps<T extends ITheme = VuiTheme> {
+    right?: RightProp<T>;
+    hoverRight?: RightProp<T>;
+}
+declare type BottomProp<T extends ITheme> = SystemProp<InsetGetter<T> | CSS.Property.Bottom, T>;
+export interface BottomProps<T extends ITheme = VuiTheme> {
+    bottom?: BottomProp<T>;
+    hoverBottom?: BottomProp<T>;
+}
+declare type LeftProp<T extends ITheme> = SystemProp<InsetGetter<T> | CSS.Property.Left, T>;
+export interface LeftProps<T extends ITheme = VuiTheme> {
+    left?: LeftProp<T>;
+    hoverLeft?: LeftProp<T>;
+}
+declare type VisibilityProp<T extends ITheme> = SystemProp<CSS.Property.Visibility, T>;
+export interface VisibilityProps<T extends ITheme = VuiTheme> {
+    visibility?: VisibilityProp<T>;
+    hoverVisibility?: VisibilityProp<T>;
+}
+declare type ObjectFitProp<T extends ITheme> = SystemProp<CSS.Property.ObjectFit, T>;
+export interface ObjectFitProps<T extends ITheme = VuiTheme> {
+    objectFit?: ObjectFitProp<T>;
+    hoverObjectFit?: ObjectFitProp<T>;
+}
+export interface LayoutProps<T extends ITheme = VuiTheme> extends DisplayProps<T>, FloatProps<T>, BoxSizingProps<T>, OverflowProps<T>, OverflowXProps<T>, OverflowYProps<T>, PositionProps<T>, ZIndexProps<T>, TopProps<T>, RightProps<T>, BottomProps<T>, LeftProps<T>, VisibilityProps<T>, ObjectFitProps<T> {
+}
+export {};

package/system/layout.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/system/sizing.d.ts

@@ -0,0 +1,36 @@
+import { ITheme, SystemProp, VariantsType } from '@xstyled/system';
+import { VuiTheme } from '../theme';
+export declare type SizeGetter<T extends ITheme = VuiTheme> = VariantsType<T['sizes']>;
+declare type WidthProp<T extends ITheme> = SystemProp<SizeGetter<T>, T>;
+export interface WidthProps<T extends ITheme = VuiTheme> {
+    w?: WidthProp<T>;
+    hoverW?: WidthProp<T>;
+}
+declare type HeightProp<T extends ITheme> = SystemProp<SizeGetter<T>, T>;
+export interface HeightProps<T extends ITheme = VuiTheme> {
+    h?: HeightProp<T>;
+    hoverH?: HeightProp<T>;
+}
+declare type MaxHeightProp<T extends ITheme> = SystemProp<SizeGetter<T>, T>;
+export interface MaxHeightProps<T extends ITheme = VuiTheme> {
+    maxH?: MaxHeightProp<T>;
+    hoverMaxH?: MaxHeightProp<T>;
+}
+declare type MinHeightProp<T extends ITheme> = SystemProp<SizeGetter<T>, T>;
+export interface MinHeightProps<T extends ITheme = VuiTheme> {
+    minH?: MinHeightProp<T>;
+    hoverMinH?: MinHeightProp<T>;
+}
+declare type MaxWidthProp<T extends ITheme> = SystemProp<SizeGetter<T>, T>;
+export interface MaxWidthProps<T extends ITheme = VuiTheme> {
+    maxW?: MaxWidthProp<T>;
+    hoverMaxW?: MaxWidthProp<T>;
+}
+declare type MinWidthProp<T extends ITheme> = SystemProp<SizeGetter<T>, T>;
+export interface MinWidthProps<T extends ITheme = VuiTheme> {
+    minW?: MinWidthProp<T>;
+    hoverMinW?: MinWidthProp<T>;
+}
+export interface SizingProps<T extends ITheme = VuiTheme> extends WidthProps<T>, HeightProps<T>, MaxWidthProps<T>, MaxHeightProps<T>, MinWidthProps<T>, MinHeightProps<T> {
+}
+export {};

package/system/sizing.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/system/space.d.ts

@@ -0,0 +1,76 @@
+import { ITheme, SystemProp, VariantsType } from '@xstyled/system';
+import { VuiTheme } from '../theme';
+export declare type SpaceGetter<T extends ITheme = VuiTheme> = VariantsType<T['space']>;
+declare type MarginProp<T extends ITheme> = SystemProp<SpaceGetter<T>, T>;
+export interface MarginProps<T extends ITheme = VuiTheme> {
+    m?: MarginProp<T>;
+    hoverM?: MarginProp<T>;
+}
+declare type MarginTopProp<T extends ITheme> = SystemProp<SpaceGetter<T>, T>;
+export interface MarginTopProps<T extends ITheme = VuiTheme> {
+    mt?: MarginTopProp<T>;
+    hoverMt?: MarginTopProp<T>;
+}
+declare type MarginRightProp<T extends ITheme> = SystemProp<SpaceGetter<T>, T>;
+export interface MarginRightProps<T extends ITheme = VuiTheme> {
+    mr?: MarginRightProp<T>;
+    hoverMr?: MarginRightProp<T>;
+}
+declare type MarginBottomProp<T extends ITheme> = SystemProp<SpaceGetter<T>, T>;
+export interface MarginBottomProps<T extends ITheme = VuiTheme> {
+    mb?: MarginBottomProp<T>;
+    hoverMb?: MarginBottomProp<T>;
+}
+declare type MarginLeftProp<T extends ITheme> = SystemProp<SpaceGetter<T>, T>;
+export interface MarginLeftProps<T extends ITheme = VuiTheme> {
+    ml?: MarginLeftProp<T>;
+    hoverMl?: MarginLeftProp<T>;
+}
+declare type MarginXProp<T extends ITheme = VuiTheme> = SystemProp<SpaceGetter<T>, T>;
+export interface MarginXProps<T extends ITheme = VuiTheme> {
+    mx?: MarginXProp<T>;
+    hoverMx?: MarginXProp<T>;
+}
+declare type MarginYProp<T extends ITheme> = SystemProp<SpaceGetter<T>, T>;
+export interface MarginYProps<T extends ITheme = VuiTheme> {
+    my?: MarginYProp<T>;
+    hoverMy?: MarginYProp<T>;
+}
+declare type PaddingProp<T extends ITheme> = SystemProp<SpaceGetter<T>, T>;
+export interface PaddingProps<T extends ITheme = VuiTheme> {
+    p?: PaddingProp<T>;
+    hoverP?: PaddingProp<T>;
+}
+declare type PaddingTopProp<T extends ITheme> = SystemProp<SpaceGetter<T>, T>;
+export interface PaddingTopProps<T extends ITheme = VuiTheme> {
+    pt?: PaddingTopProp<T>;
+    hoverPt?: PaddingTopProp<T>;
+}
+declare type PaddingRightProp<T extends ITheme> = SystemProp<SpaceGetter<T>, T>;
+export interface PaddingRightProps<T extends ITheme = VuiTheme> {
+    pr?: PaddingRightProp<T>;
+    hoverPr?: PaddingRightProp<T>;
+}
+declare type PaddingBottomProp<T extends ITheme> = SystemProp<SpaceGetter<T>, T>;
+export interface PaddingBottomProps<T extends ITheme = VuiTheme> {
+    pb?: PaddingBottomProp<T>;
+    hoverPb?: PaddingBottomProp<T>;
+}
+declare type PaddingLeftProp<T extends ITheme> = SystemProp<SpaceGetter<T>, T>;
+export interface PaddingLeftProps<T extends ITheme = VuiTheme> {
+    pl?: PaddingLeftProp<T>;
+    hoverPl?: PaddingLeftProp<T>;
+}
+declare type PaddingXProp<T extends ITheme> = SystemProp<SpaceGetter<T>, T>;
+export interface PaddingXProps<T extends ITheme = VuiTheme> {
+    px?: PaddingXProp<T>;
+    hoverPx?: PaddingXProp<T>;
+}
+declare type PaddingYProp<T extends ITheme> = SystemProp<SpaceGetter<T>, T>;
+export interface PaddingYProps<T extends ITheme = VuiTheme> {
+    py?: PaddingYProp<T>;
+    hoverPy?: PaddingYProp<T>;
+}
+export interface SpaceProps<T extends ITheme = VuiTheme> extends MarginProps<T>, MarginTopProps<T>, MarginRightProps<T>, MarginBottomProps<T>, MarginLeftProps<T>, MarginXProps<T>, MarginYProps<T>, PaddingProps<T>, PaddingTopProps<T>, PaddingRightProps<T>, PaddingBottomProps<T>, PaddingLeftProps<T>, PaddingXProps<T>, PaddingYProps<T> {
+}
+export {};

package/system/space.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/system/transforms.d.ts

@@ -0,0 +1,57 @@
+import { ITheme, SystemProp, VariantsType } from '@xstyled/system';
+import * as CSS from 'csstype';
+import { VuiTheme } from '../theme';
+export declare type TransformGetter<T extends ITheme = VuiTheme> = VariantsType<T['transforms']>;
+declare type TransformProp<T extends ITheme> = SystemProp<boolean, T>;
+export interface TransformProps<T extends ITheme = VuiTheme> {
+    transform?: TransformProp<T>;
+    hoverTransform?: TransformProp<T>;
+}
+declare type TransformOriginProp<T extends ITheme> = SystemProp<CSS.Property.TransformOrigin, T>;
+export interface TransformOriginProps<T extends ITheme = VuiTheme> {
+    transformOrigin?: TransformOriginProp<T>;
+    hoverTransformOrigin?: TransformOriginProp<T>;
+}
+declare type TranslateXProp<T extends ITheme> = SystemProp<number | string, T>;
+export interface TranslateXProps<T extends ITheme = VuiTheme> {
+    translateX?: TranslateXProp<T>;
+    hoverTranslateX?: TranslateXProp<T>;
+}
+declare type TranslateYProp<T extends ITheme> = SystemProp<number | string, T>;
+export interface TranslateYProps<T extends ITheme = VuiTheme> {
+    translateY?: TranslateYProp<T>;
+    hoverTranslateY?: TranslateYProp<T>;
+}
+declare type RotateProp<T extends ITheme> = SystemProp<number | string, T>;
+export interface RotateProps<T extends ITheme = VuiTheme> {
+    rotate?: RotateProp<T>;
+    hoverRotate?: RotateProp<T>;
+}
+declare type SkewXProp<T extends ITheme> = SystemProp<number | string, T>;
+export interface SkewXProps<T extends ITheme = VuiTheme> {
+    skewX?: SkewXProp<T>;
+    hoverSkewX?: SkewXProp<T>;
+}
+declare type SkewYProp<T extends ITheme> = SystemProp<number | string, T>;
+export interface SkewYProps<T extends ITheme = VuiTheme> {
+    skewY?: SkewYProp<T>;
+    hoverSkewY?: SkewYProp<T>;
+}
+declare type ScaleProp<T extends ITheme> = SystemProp<number | string, T>;
+export interface ScaleProps<T extends ITheme = VuiTheme> {
+    scale?: ScaleProp<T>;
+    hoverScale?: ScaleProp<T>;
+}
+declare type ScaleXProp<T extends ITheme> = SystemProp<number | string, T>;
+export interface ScaleXProps<T extends ITheme = VuiTheme> {
+    scaleX?: ScaleXProp<T>;
+    hoverScaleX?: ScaleXProp<T>;
+}
+declare type ScaleYProp<T extends ITheme> = SystemProp<number | string, T>;
+export interface ScaleYProps<T extends ITheme = VuiTheme> {
+    scaleY?: ScaleYProp<T>;
+    hoverScaleY?: ScaleYProp<T>;
+}
+export interface TransformsProps<T extends ITheme = VuiTheme> extends TransformProps<T>, TransformOriginProps<T>, TranslateXProps<T>, TranslateYProps<T>, RotateProps<T>, SkewXProps<T>, SkewYProps<T>, ScaleProps<T>, ScaleXProps<T>, ScaleYProps<T> {
+}
+export {};

package/system/transforms.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });