@veracity/vui 1.0.0 → 1.1.0

package/src/system/borders.ts

@@ -11,192 +11,192 @@ export type RingWidthGetter = VariantsType<VuiTheme['ringWidths']>
 
 type BorderProp = SystemProp<BorderGetter, VuiTheme>
 export type BorderProps = {
-	border?: BorderProp
-	hoverBorder?: BorderProp
+  border?: BorderProp
+  hoverBorder?: BorderProp
 }
 
 type BorderTopProp = SystemProp<BorderGetter, VuiTheme>
 export type BorderTopProps = {
-	borderTop?: BorderTopProp
+  borderTop?: BorderTopProp
 }
 
 type BorderRightProp = SystemProp<BorderGetter, VuiTheme>
 export type BorderRightProps = {
-	borderRight?: BorderRightProp
+  borderRight?: BorderRightProp
 }
 
 type BorderBottomProp = SystemProp<BorderGetter, VuiTheme>
 export type BorderBottomProps = {
-	borderBottom?: BorderBottomProp
+  borderBottom?: BorderBottomProp
 }
 
 type BorderLeftProp = SystemProp<BorderGetter, VuiTheme>
 export type BorderLeftProps = {
-	borderLeft?: BorderLeftProp
+  borderLeft?: BorderLeftProp
 }
 
 type BorderColorProp = SystemProp<ColorGetter, VuiTheme>
 export type BorderColorProps = {
-	borderColor?: BorderColorProp
-	disabledBorderColor?: BorderColorProp
-	focusBorderColor?: BorderColorProp
-	hoverBorderColor?: BorderColorProp
-	focusWithinBorderColor?: BorderColorProp
+  borderColor?: BorderColorProp
+  disabledBorderColor?: BorderColorProp
+  focusBorderColor?: BorderColorProp
+  hoverBorderColor?: BorderColorProp
+  focusWithinBorderColor?: BorderColorProp
 }
 
 type BorderTopColorProp = SystemProp<ColorGetter, VuiTheme>
 export type BorderTopColorProps = {
-	borderTopColor?: BorderTopColorProp
+  borderTopColor?: BorderTopColorProp
 }
 
 type BorderRightColorProp = SystemProp<ColorGetter, VuiTheme>
 export type BorderRightColorProps = {
-	borderRightColor?: BorderRightColorProp
+  borderRightColor?: BorderRightColorProp
 }
 
 type BorderBottomColorProp = SystemProp<ColorGetter, VuiTheme>
 export type BorderBottomColorProps = {
-	borderBottomColor?: BorderBottomColorProp
+  borderBottomColor?: BorderBottomColorProp
 }
 
 type BorderLeftColorProp = SystemProp<ColorGetter, VuiTheme>
 export type BorderLeftColorProps = {
-	borderLeftColor?: BorderLeftColorProp
+  borderLeftColor?: BorderLeftColorProp
 }
 
 type BorderWidthProp = SystemProp<BorderWidthGetter, VuiTheme>
 export type BorderWidthProps = {
-	borderWidth?: BorderWidthProp
-	hoverBorderWidth?: BorderWidthProp
+  borderWidth?: BorderWidthProp
+  hoverBorderWidth?: BorderWidthProp
 }
 
 type BorderTopWidthProp = SystemProp<BorderWidthGetter, VuiTheme>
 export type BorderTopWidthProps = {
-	borderTopWidth?: BorderTopWidthProp
+  borderTopWidth?: BorderTopWidthProp
 }
 
 type BorderRightWidthProp = SystemProp<BorderWidthGetter, VuiTheme>
 export type BorderRightWidthProps = {
-	borderRightWidth?: BorderRightWidthProp
+  borderRightWidth?: BorderRightWidthProp
 }
 
 type BorderBottomWidthProp = SystemProp<BorderWidthGetter, VuiTheme>
 export type BorderBottomWidthProps = {
-	borderBottomWidth?: BorderBottomWidthProp
+  borderBottomWidth?: BorderBottomWidthProp
 }
 
 type BorderLeftWidthProp = SystemProp<BorderWidthGetter, VuiTheme>
 export type BorderLeftWidthProps = {
-	borderLeftWidth?: BorderLeftWidthProp
+  borderLeftWidth?: BorderLeftWidthProp
 }
 
 type BorderStyleProp = SystemProp<BorderStyleGetter, VuiTheme>
 export type BorderStyleProps = {
-	borderStyle?: BorderStyleProp
-	hoverBorderStyle?: BorderStyleProp
+  borderStyle?: BorderStyleProp
+  hoverBorderStyle?: BorderStyleProp
 }
 
 export type BorderRadiusProp = SystemProp<RadiusGetter, VuiTheme>
 export type BorderRadiusProps = {
-	borderRadius?: BorderRadiusProp
-	hoverBorderRadius?: BorderRadiusProp
+  borderRadius?: BorderRadiusProp
+  hoverBorderRadius?: BorderRadiusProp
 }
 
 type OutlineProp = SystemProp<BorderGetter, VuiTheme>
 export type OutlineProps = {
-	outline?: OutlineProp
+  outline?: OutlineProp
 }
 
 type OutlineColorProp = SystemProp<ColorGetter, VuiTheme>
 export type OutlineColorProps = {
-	outlineColor?: OutlineColorProp
+  outlineColor?: OutlineColorProp
 }
 
 type OutlineWidthProp = SystemProp<BorderWidthGetter, VuiTheme>
 export type OutlineWidthProps = {
-	outlineWidth?: OutlineWidthProp
+  outlineWidth?: OutlineWidthProp
 }
 
 type OutlineStyleProp = SystemProp<BorderStyleGetter, VuiTheme>
 export type OutlineStyleProps = {
-	outlineStyle?: OutlineStyleProp
+  outlineStyle?: OutlineStyleProp
 }
 
 type DivideXProp = SystemProp<BorderWidthGetter, VuiTheme>
 export type DivideXProps = {
-	divideX?: DivideXProp
+  divideX?: DivideXProp
 }
 
 type DivideYProp = SystemProp<BorderWidthGetter, VuiTheme>
 export type DivideYProps = {
-	divideY?: DivideYProp
+  divideY?: DivideYProp
 }
 
 type DivideXReverseProp = SystemProp<BorderWidthGetter, VuiTheme>
 export type DivideXReverseProps = {
-	divideXReverse?: DivideXReverseProp
+  divideXReverse?: DivideXReverseProp
 }
 
 type DivideYReverseProp = SystemProp<BorderWidthGetter, VuiTheme>
 export type DivideYReverseProps = {
-	divideYReverse?: DivideYReverseProp
+  divideYReverse?: DivideYReverseProp
 }
 
 type DivideColorProp = SystemProp<ColorGetter, VuiTheme>
 export type DivideColorProps = {
-	divideColor?: DivideColorProp
-	hoverDivideColor?: DivideColorProp
+  divideColor?: DivideColorProp
+  hoverDivideColor?: DivideColorProp
 }
 
 type DivideStyleProp = SystemProp<BorderStyleGetter, VuiTheme>
 export type DivideStyleProps = {
-	divideStyle?: DivideStyleProp
+  divideStyle?: DivideStyleProp
 }
 
 type RingProp = SystemProp<RingWidthGetter, VuiTheme>
 export type RingProps = {
-	ring?: RingProp
-	focusRing?: RingProp
-	focusVisibleRing?: RingProp
-	focusWithinRing?: RingProp
-	hoverRing?: RingProp
+  ring?: RingProp
+  focusRing?: RingProp
+  focusVisibleRing?: RingProp
+  focusWithinRing?: RingProp
+  hoverRing?: RingProp
 }
 
 type RingColorProp = SystemProp<ColorGetter, VuiTheme>
 export type RingColorProps = {
-	ringColor?: RingColorProp
-	focusRingColor?: RingColorProp
-	focusVisibleRingColor?: RingColorProp
-	focusWithinRingColor?: RingColorProp
-	hoverRingColor?: RingColorProp
+  ringColor?: RingColorProp
+  focusRingColor?: RingColorProp
+  focusVisibleRingColor?: RingColorProp
+  focusWithinRingColor?: RingColorProp
+  hoverRingColor?: RingColorProp
 }
 
 export type BordersProps = 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
+  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

package/src/system/custom.ts

@@ -1,44 +1,44 @@
 import { style } from '@xstyled/styled-components'
 
 export type IsTruncatedProps = {
-	isTruncated?: boolean
+  isTruncated?: boolean
 }
 
 /** Provides styling to truncate single-line text. */
 export const isTruncated = style({
-	prop: 'isTruncated',
-	cssProperty: function () {
-		return {
-			overflow: 'hidden',
-			'text-overflow': 'ellipsis',
-			'white-space': 'nowrap'
-		}
-	},
-	states: {}
+  prop: 'isTruncated',
+  cssProperty: function () {
+    return {
+      overflow: 'hidden',
+      'text-overflow': 'ellipsis',
+      'white-space': 'nowrap'
+    }
+  },
+  states: {}
 })
 
 export type MaxLinesProps = {
-	maxLines?: number
+  maxLines?: number
 }
 
 /** Provides styling to truncate multi-line text. */
 export const maxLines = style({
-	prop: 'maxLines',
-	cssProperty: function (value: any) {
-		return {
-			display: '-webkit-box',
-			overflow: 'hidden',
-			'-webkit-line-clamp': `${value}`,
-			'-webkit-box-orient': 'vertical'
-		}
-	},
-	states: {}
+  prop: 'maxLines',
+  cssProperty: function (value: any) {
+    return {
+      display: '-webkit-box',
+      overflow: 'hidden',
+      '-webkit-line-clamp': `${value}`,
+      '-webkit-box-orient': 'vertical'
+    }
+  },
+  states: {}
 })
 
 export type WordBreakProps = {
-	wordBreak?: 'normal' | 'break-all' | 'keep-all' | 'break-word'
+  wordBreak?: 'normal' | 'break-all' | 'keep-all' | 'break-word'
 }
 
 export const wordBreak = style({
-	prop: 'wordBreak'
+  prop: 'wordBreak'
 })

package/src/system/effects.ts

@@ -8,19 +8,19 @@ export type ShadowGetter = VariantsType<VuiTheme['shadows']>
 
 type OpacityProp = SystemProp<CSS.Property.Opacity, VuiTheme>
 export type OpacityProps = {
-	opacity?: OpacityProp
-	hoverOpacity?: OpacityProp
+  opacity?: OpacityProp
+  hoverOpacity?: OpacityProp
 }
 
 type BoxShadowProp = SystemProp<ShadowGetter | AnyString, VuiTheme>
 export type BoxShadowProps = {
-	boxShadow?: BoxShadowProp
-	hoverBoxShadow?: BoxShadowProp
+  boxShadow?: BoxShadowProp
+  hoverBoxShadow?: BoxShadowProp
 }
 
 type TextShadowProp = SystemProp<ShadowGetter | AnyString, VuiTheme>
 export type TextShadowProps = {
-	textShadow?: TextShadowProp
+  textShadow?: TextShadowProp
 }
 
 export type EffectsProps = OpacityProps & BoxShadowProps & TextShadowProps

package/src/system/flexboxGrids.ts

@@ -4,12 +4,12 @@ import { VuiTheme } from '../theme'
 
 type RowProp = SystemProp<boolean, VuiTheme>
 export type RowProps = {
-	row?: RowProp
+  row?: RowProp
 }
 
 type ColProp = SystemProp<true | 'auto' | string | number, VuiTheme>
 export type ColProps = {
-	col?: ColProp
+  col?: ColProp
 }
 
 export type FlexboxGridsProps = RowProps & ColProps

package/src/system/flexboxes.ts

@@ -6,82 +6,82 @@ import { DisplayProps } from './layout'
 
 type AlignItemsProp = SystemProp<CSS.Property.AlignItems, VuiTheme>
 export type AlignItemsProps = {
-	alignItems?: AlignItemsProp
+  alignItems?: AlignItemsProp
 }
 
 type AlignContentProp = SystemProp<CSS.Property.AlignContent, VuiTheme>
 export type AlignContentProps = {
-	alignContent?: AlignContentProp
+  alignContent?: AlignContentProp
 }
 
 type JustifyContentProp = SystemProp<CSS.Property.JustifyContent, VuiTheme>
 export type JustifyContentProps = {
-	justifyContent?: JustifyContentProp
+  justifyContent?: JustifyContentProp
 }
 
 type JustifyItemsProp = SystemProp<CSS.Property.JustifyItems, VuiTheme>
 export type JustifyItemsProps = {
-	justifyItems?: JustifyItemsProp
+  justifyItems?: JustifyItemsProp
 }
 
 type FlexWrapProp = SystemProp<CSS.Property.FlexWrap, VuiTheme>
 export type FlexWrapProps = {
-	flexWrap?: FlexWrapProp
+  flexWrap?: FlexWrapProp
 }
 
 type FlexGrowProp = SystemProp<CSS.Property.FlexGrow, VuiTheme>
 export type FlexGrowProps = {
-	flexGrow?: FlexGrowProp
+  flexGrow?: FlexGrowProp
 }
 
 type FlexShrinkProp = SystemProp<CSS.Property.FlexShrink, VuiTheme>
 export type FlexShrinkProps = {
-	flexShrink?: FlexShrinkProp
+  flexShrink?: FlexShrinkProp
 }
 
 type FlexBasisProp = SystemProp<CSS.Property.FlexBasis, VuiTheme>
 export type FlexBasisProps = {
-	flexBasis?: FlexBasisProp
-	hoverFlexBasis?: FlexBasisProp
+  flexBasis?: FlexBasisProp
+  hoverFlexBasis?: FlexBasisProp
 }
 
 type FlexDirectionProp = SystemProp<CSS.Property.FlexDirection, VuiTheme>
 export type FlexDirectionProps = {
-	flexDirection?: FlexDirectionProp
+  flexDirection?: FlexDirectionProp
 }
 
 type FlexProp = SystemProp<CSS.Property.Flex, VuiTheme>
 export type FlexProps = {
-	flex?: FlexProp
-	hoverFlex?: FlexProp
+  flex?: FlexProp
+  hoverFlex?: FlexProp
 }
 
 type JustifySelfProp = SystemProp<CSS.Property.JustifySelf, VuiTheme>
 export type JustifySelfProps = {
-	justifySelf?: JustifySelfProp
+  justifySelf?: JustifySelfProp
 }
 
 type AlignSelfProp = SystemProp<CSS.Property.AlignSelf, VuiTheme>
 export type AlignSelfProps = {
-	alignSelf?: AlignSelfProp
+  alignSelf?: AlignSelfProp
 }
 
 type OrderProp = SystemProp<CSS.Property.Order, VuiTheme>
 export type OrderProps = {
-	order?: OrderProp
+  order?: OrderProp
 }
 
 export type FlexboxesProps = DisplayProps &
-	AlignItemsProps &
-	AlignContentProps &
-	JustifyContentProps &
-	JustifyItemsProps &
-	FlexWrapProps &
-	FlexGrowProps &
-	FlexShrinkProps &
-	FlexBasisProps &
-	FlexDirectionProps &
-	FlexProps &
-	JustifySelfProps &
-	AlignSelfProps &
-	OrderProps
+  AlignItemsProps &
+  AlignContentProps &
+  JustifyContentProps &
+  JustifyItemsProps &
+  FlexWrapProps &
+  FlexGrowProps &
+  FlexShrinkProps &
+  FlexBasisProps &
+  FlexDirectionProps &
+  FlexProps &
+  JustifySelfProps &
+  AlignSelfProps &
+  OrderProps

package/src/system/grids.ts

@@ -9,73 +9,73 @@ export type GridTemplateRowsGetter = VariantsType<VuiTheme['gridTemplateRows']>
 
 type GapProp = SystemProp<SpaceGetter | CSS.Property.Gap, VuiTheme>
 export type GapProps = {
-	gap?: GapProp
+  gap?: GapProp
 }
 
 type ColumnGapProp = SystemProp<SpaceGetter | CSS.Property.ColumnGap, VuiTheme>
 export type ColumnGapProps = {
-	columnGap?: ColumnGapProp
+  columnGap?: ColumnGapProp
 }
 
 type RowGapProp = SystemProp<SpaceGetter | CSS.Property.RowGap, VuiTheme>
 export type RowGapProps = {
-	rowGap?: RowGapProp
+  rowGap?: RowGapProp
 }
 
 type GridColumnProp = SystemProp<CSS.Property.GridColumn, VuiTheme>
 export type GridColumnProps = {
-	gridColumn?: GridColumnProp
+  gridColumn?: GridColumnProp
 }
 
 type GridRowProp = SystemProp<CSS.Property.GridRow, VuiTheme>
 export type GridRowProps = {
-	gridRow?: GridRowProp
+  gridRow?: GridRowProp
 }
 
 type GridAutoFlowProp = SystemProp<CSS.Property.GridAutoFlow, VuiTheme>
 export type GridAutoFlowProps = {
-	gridAutoFlow?: GridAutoFlowProp
+  gridAutoFlow?: GridAutoFlowProp
 }
 
 type GridAutoColumnsProp = SystemProp<CSS.Property.GridAutoColumns, VuiTheme>
 export type GridAutoColumnsProps = {
-	gridAutoColumns?: GridAutoColumnsProp
+  gridAutoColumns?: GridAutoColumnsProp
 }
 
 type GridAutoRowsProp = SystemProp<CSS.Property.GridAutoRows, VuiTheme>
 export type GridAutoRowsProps = {
-	gridAutoRows?: GridAutoRowsProp
+  gridAutoRows?: GridAutoRowsProp
 }
 
 type GridTemplateColumnsProp = SystemProp<GridTemplateColumnsGetter | CSS.Property.GridTemplateColumns, VuiTheme>
 export type GridTemplateColumnsProps = {
-	gridTemplateColumns?: GridTemplateColumnsProp
+  gridTemplateColumns?: GridTemplateColumnsProp
 }
 
 type GridTemplateRowsProp = SystemProp<GridTemplateRowsGetter | CSS.Property.GridTemplateRows, VuiTheme>
 export type GridTemplateRowsProps = {
-	gridTemplateRows?: GridTemplateRowsProp
+  gridTemplateRows?: GridTemplateRowsProp
 }
 
 type GridTemplateAreasProp = SystemProp<CSS.Property.GridTemplateAreas, VuiTheme>
 export type GridTemplateAreasProps = {
-	gridTemplateAreas?: GridTemplateAreasProp
+  gridTemplateAreas?: GridTemplateAreasProp
 }
 
 type GridAreaProp = SystemProp<CSS.Property.GridArea, VuiTheme>
 export type GridAreaProps = {
-	gridArea?: GridAreaProp
+  gridArea?: GridAreaProp
 }
 
 export type GridsProps = GapProps &
-	ColumnGapProps &
-	RowGapProps &
-	GridColumnProps &
-	GridRowProps &
-	GridAutoFlowProps &
-	GridAutoColumnsProps &
-	GridAutoRowsProps &
-	GridTemplateColumnsProps &
-	GridTemplateRowsProps &
-	GridTemplateAreasProps &
-	GridAreaProps
+  ColumnGapProps &
+  RowGapProps &
+  GridColumnProps &
+  GridRowProps &
+  GridAutoFlowProps &
+  GridAutoColumnsProps &
+  GridAutoRowsProps &
+  GridTemplateColumnsProps &
+  GridTemplateRowsProps &
+  GridTemplateAreasProps &
+  GridAreaProps

package/src/system/interactivity.ts

@@ -5,27 +5,27 @@ import { VuiTheme } from '../theme'
 
 type AppearanceProp = SystemProp<CSS.Property.Appearance, VuiTheme>
 export type AppearanceProps = {
-	appearance?: AppearanceProp
+  appearance?: AppearanceProp
 }
 
 type CursorProp = SystemProp<CSS.Property.Cursor, VuiTheme>
 export type CursorProps = {
-	cursor?: CursorProp
+  cursor?: CursorProp
 }
 
 type PointerEventsProp = SystemProp<CSS.Property.PointerEvents, VuiTheme>
 export type PointerEventsProps = {
-	pointerEvents?: PointerEventsProp
+  pointerEvents?: PointerEventsProp
 }
 
 type ResizeProp = SystemProp<CSS.Property.Resize, VuiTheme>
 export type ResizeProps = {
-	resize?: ResizeProp
+  resize?: ResizeProp
 }
 
 type UserSelectProp = SystemProp<CSS.Property.UserSelect, VuiTheme>
 export type UserSelectProps = {
-	userSelect?: UserSelectProp
+  userSelect?: UserSelectProp
 }
 
 export type InteractivityProps = AppearanceProps & CursorProps & PointerEventsProps & ResizeProps & UserSelectProps