@codecademy/variance 0.21.1-alpha.d9da73.0 → 0.21.1

package/dist/createTheme/types.d.ts

@@ -9,21 +9,21 @@ import { AbstractTheme } from '../types/theme';
  *
  * The resulting type is then rejoined with keys that cannot be mutated (breakpoints) as the next version of Theme
  */
-export declare type MergeTheme<Base extends AbstractTheme, Next, Unmergable = Record<'breakpoints', Base['breakpoints']>> = Unmergable & Merge<Base, Next>;
+export type MergeTheme<Base extends AbstractTheme, Next, Unmergable = Record<'breakpoints', Base['breakpoints']>> = Unmergable & Merge<Base, Next>;
 /** This merges at 2 levels of depth */
-export declare type Merge<A, B> = {
+export type Merge<A, B> = {
     [K in keyof (A & B)]: K extends keyof B ? K extends keyof A ? AssignValueIfUnmergable<A[K], B[K]> : B[K] : K extends keyof A ? A[K] : never;
 };
 /** Extract mergable objects */
-export declare type Mergable<T> = Exclude<T, ((...args: any) => any) | string | boolean | symbol | number | any[]>;
+export type Mergable<T> = Exclude<T, ((...args: any) => any) | string | boolean | symbol | number | any[]>;
 /** Return B if either A or B is unmergable */
-export declare type AssignValueIfUnmergable<A, B> = Mergable<A> extends never ? B : Mergable<B> extends never ? B : Assign<A, B>;
+export type AssignValueIfUnmergable<A, B> = Mergable<A> extends never ? B : Mergable<B> extends never ? B : Assign<A, B>;
 /** Prefer all values from B */
-export declare type Assign<A, B> = {
+export type Assign<A, B> = {
     [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never;
 };
 /** These are keys that are consistent for all theme builds - they are loosely typed as they are not meant to be accessed directly */
-export declare type PrivateThemeKeys = {
+export type PrivateThemeKeys = {
     _variables: Record<string, CSSObject>;
     _tokens: Record<string | number, any>;
 };
@@ -39,4 +39,4 @@ export declare type PrivateThemeKeys = {
  *
  * `button-bg-hover`
  * */
-export declare type ColorModeConfig<Colors> = Record<string, Colors | Record<string, Colors> | Record<string, Colors | Record<string, Colors>>>;
+export type ColorModeConfig<Colors> = Record<string, Colors | Record<string, Colors> | Record<string, Colors | Record<string, Colors>>>;

package/dist/scales/createScaleLookup.d.ts

@@ -1,5 +1,5 @@
 import { Prop } from '../types/config';
 import { ThemeProps } from '../types/props';
-declare type GetScaleValue = (val: string | number, props: ThemeProps) => string | number | undefined;
+type GetScaleValue = (val: string | number, props: ThemeProps) => string | number | undefined;
 export declare const createScaleLookup: (scale: Prop['scale']) => GetScaleValue;
 export {};

package/dist/types/config.d.ts

@@ -2,8 +2,8 @@ import { Theme } from '@emotion/react';
 import { DefaultCSSPropertyValue, PropertyTypes } from './properties';
 import { AbstractProps, CSSObject, CSSPropMap, CSSProps, ResponsiveProp, ThemeProps } from './props';
 import { AllUnionKeys, Key, KeyFromUnion } from './utils';
-export declare type MapScale = Record<string | number, string | number>;
-export declare type ArrayScale = readonly (string | number)[] & {
+export type MapScale = Record<string | number, string | number>;
+export type ArrayScale = readonly (string | number)[] & {
     length: 0;
 };
 export interface BaseProperty {
@@ -23,9 +23,9 @@ export interface AbstractParser {
     propNames: string[];
     config: Record<string, AbstractPropTransformer>;
 }
-export declare type PropertyValues<Property extends keyof PropertyTypes, All extends boolean = false> = Exclude<PropertyTypes<All extends true ? DefaultCSSPropertyValue : never>[Property], All extends true ? never : object | any[]>;
-export declare type ScaleValue<Config extends Prop> = Config['scale'] extends keyof Theme ? keyof Theme[Config['scale']] | PropertyValues<Config['property']> : Config['scale'] extends MapScale ? keyof Config['scale'] | PropertyValues<Config['property']> : Config['scale'] extends ArrayScale ? Config['scale'][number] | PropertyValues<Config['property']> : PropertyValues<Config['property'], true>;
-export declare type Scale<Config extends Prop> = ResponsiveProp<ScaleValue<Config> | ((theme: Theme) => ScaleValue<Config>)>;
+export type PropertyValues<Property extends keyof PropertyTypes, All extends boolean = false> = Exclude<PropertyTypes<All extends true ? DefaultCSSPropertyValue : never>[Property], All extends true ? never : object | any[]>;
+export type ScaleValue<Config extends Prop> = Config['scale'] extends keyof Theme ? keyof Theme[Config['scale']] | PropertyValues<Config['property']> : Config['scale'] extends MapScale ? keyof Config['scale'] | PropertyValues<Config['property']> : Config['scale'] extends ArrayScale ? Config['scale'][number] | PropertyValues<Config['property']> : PropertyValues<Config['property'], true>;
+export type Scale<Config extends Prop> = ResponsiveProp<ScaleValue<Config> | ((theme: Theme) => ScaleValue<Config>)>;
 export interface TransformFn<P extends string, Config extends Prop> {
     (value: Scale<Config> | Scale<Config>, prop: P, props: ThemeProps<{
         [K in P]?: Scale<Config>;
@@ -35,7 +35,7 @@ export interface PropTransformer<P extends string, C extends Prop> extends Abstr
     prop: P;
     styleFn: TransformFn<P, C>;
 }
-export declare type TransformerMap<Config extends Record<string, Prop>> = {
+export type TransformerMap<Config extends Record<string, Prop>> = {
     [P in Key<keyof Config>]: PropTransformer<Key<P>, Config[P]>;
 };
 export interface Parser<Config extends Record<string, AbstractPropTransformer>> {
@@ -43,7 +43,7 @@ export interface Parser<Config extends Record<string, AbstractPropTransformer>>
     propNames: (keyof Config)[];
     config: Config;
 }
-export declare type Compose<Args extends AbstractParser[]> = {
+export type Compose<Args extends AbstractParser[]> = {
     [K in AllUnionKeys<Args[number]['config']>]: KeyFromUnion<Args[number]['config'], K>;
 };
 export interface Variant<P extends AbstractParser> {
@@ -60,12 +60,12 @@ export interface States<P extends AbstractParser> {
 export interface CSS<P extends AbstractParser> {
     <Props extends AbstractProps>(config: CSSProps<Props, SystemProps<P>>): (props: ThemeProps) => CSSObject;
 }
-export declare type ParserProps<Config extends Record<string, AbstractPropTransformer>> = ThemeProps<{
+export type ParserProps<Config extends Record<string, AbstractPropTransformer>> = ThemeProps<{
     [P in keyof Config]?: Parameters<Config[P]['styleFn']>[2][Config[P]['prop']];
 }>;
-export declare type SystemProps<P extends AbstractParser> = {
+export type SystemProps<P extends AbstractParser> = {
     [K in keyof Omit<Parameters<P>[0], 'theme'>]: Omit<Parameters<P>[0], 'theme'>[K];
 };
-export declare type VariantProps<T extends string, V> = {
+export type VariantProps<T extends string, V> = {
     [Key in T]?: V;
 };

package/dist/types/properties.d.ts

@@ -1,10 +1,10 @@
 import { Globals, StandardProperties, VendorProperties } from 'csstype';
-declare type ColorProperties = 'color' | `${string}Color`;
-declare type ColorGlobals = {
+type ColorProperties = 'color' | `${string}Color`;
+type ColorGlobals = {
     [K in Extract<keyof StandardProperties, ColorProperties>]?: Globals | 'currentColor' | 'transparent' | (string & {});
 };
-declare type SizeProperties = 'left' | 'right' | 'top' | 'bottom' | 'inset' | 'width' | 'height' | `${string}${'Width' | 'Height'}`;
-declare type SizeGlobals = {
+type SizeProperties = 'left' | 'right' | 'top' | 'bottom' | 'inset' | 'width' | 'height' | `${string}${'Width' | 'Height'}`;
+type SizeGlobals = {
     [K in Extract<keyof StandardProperties, SizeProperties>]?: StandardProperties[K] | (number & {});
 };
 /** This is a placeholder type for CSS properties that may not have any specific global values (outlineOffset).
@@ -12,7 +12,7 @@ declare type SizeGlobals = {
  *
  * This ensures that autosuggestions will still work for literal types but still allow any string for certain properties.
  */
-export declare type DefaultCSSPropertyValue = (string & {}) | 0;
+export type DefaultCSSPropertyValue = (string & {}) | 0;
 export interface PropertyTypes<Overrides = DefaultCSSPropertyValue> extends Omit<StandardProperties<Overrides>, keyof ColorGlobals | keyof SizeGlobals>, ColorGlobals, SizeGlobals {
 }
 export interface VendorPropertyTypes<Overrides = DefaultCSSPropertyValue> extends VendorProperties<Overrides> {

package/dist/types/props.d.ts

@@ -1,7 +1,7 @@
 import { Theme } from '@emotion/react';
 import { AbstractParser, Scale } from './config';
 import { CSSPropertyTypes } from './properties';
-export declare type AbstractProps = ThemeProps<Record<string, unknown>>;
+export type AbstractProps = ThemeProps<Record<string, unknown>>;
 interface BreakpointKeys<T = string> {
     xs: T;
     sm: T;
@@ -13,7 +13,7 @@ export interface BreakpointCache {
     map: BreakpointKeys;
     array: string[];
 }
-export declare type ThemeProps<Props = {}> = Props & {
+export type ThemeProps<Props = {}> = Props & {
     theme?: Theme;
 };
 export interface MediaQueryArray<T> {
@@ -32,16 +32,16 @@ export interface MediaQueryMap<T> {
     lg?: T;
     xl?: T;
 }
-export declare type ResponsiveProp<T> = T | MediaQueryMap<T> | MediaQueryArray<T>;
+export type ResponsiveProp<T> = T | MediaQueryMap<T> | MediaQueryArray<T>;
 export interface CSSObject {
     [key: string]: string | number | CSSObject | undefined;
 }
-export declare type CSSPropMap<Props, System> = {
+export type CSSPropMap<Props, System> = {
     [K in keyof Props]?: CSSProps<Props[K], System>;
 };
-export declare type CSSProps<Props, System> = {
+export type CSSProps<Props, System> = {
     [K in keyof Props]?: K extends keyof System ? System[K] : K extends keyof CSSPropertyTypes ? CSSPropertyTypes[K] : Omit<CSSPropertyTypes, keyof System> & Omit<System, 'theme'>;
 };
-export declare type StyleProps<T extends (args: AbstractProps) => CSSObject> = Parameters<T>[0];
-export declare type ScaleValue<P extends AbstractParser, Prop extends keyof P['config']> = Scale<P['config'][Prop]>;
+export type StyleProps<T extends (args: AbstractProps) => CSSObject> = Parameters<T>[0];
+export type ScaleValue<P extends AbstractParser, Prop extends keyof P['config']> = Scale<P['config'][Prop]>;
 export {};

package/dist/types/utils.d.ts

@@ -1,3 +1,3 @@
-export declare type AllUnionKeys<T> = T extends any ? keyof T : never;
-export declare type KeyFromUnion<T, K> = T extends any ? K extends keyof T ? T[K] : never : never;
-export declare type Key<T> = T extends string ? T : never;
+export type AllUnionKeys<T> = T extends any ? keyof T : never;
+export type KeyFromUnion<T, K> = T extends any ? K extends keyof T ? T[K] : never : never;
+export type Key<T> = T extends string ? T : never;

package/dist/utils/flattenScale.d.ts

@@ -2,19 +2,19 @@
  * Returns an exhaustive list of all possible paths of an object T for keys K.
  * Possibilities are returned as `k1.k2.k3`.
  */
-export declare type FindPath<T, K extends keyof T, D extends string = '.'> = K extends string | number ? T[K] extends Record<string | number, any> ? T[K] extends ArrayLike<any> ? K | `${K}${D}${FindPath<T[K], Exclude<keyof T[K], keyof any[]>, D>}` : K | `${K}${D}${FindPath<T[K], keyof T[K], D>}` : K : never;
+export type FindPath<T, K extends keyof T, D extends string = '.'> = K extends string | number ? T[K] extends Record<string | number, any> ? T[K] extends ArrayLike<any> ? K | `${K}${D}${FindPath<T[K], Exclude<keyof T[K], keyof any[]>, D>}` : K | `${K}${D}${FindPath<T[K], keyof T[K], D>}` : K : never;
 /** Returns valid paths of object T */
-export declare type Path<T, D extends string = '.'> = FindPath<T, keyof T, D> | keyof T;
+export type Path<T, D extends string = '.'> = FindPath<T, keyof T, D> | keyof T;
 /** Returns the value of a valid path P `k1.k2.k3` in object T */
-export declare type PathValue<T, P extends Path<T, D>, D extends string = '.'> = P extends `${infer K}${D}${infer Rest}` ? K extends keyof T ? Rest extends Path<T[K], D> ? PathValue<T[K], Rest, D> : never : never : P extends keyof T ? T[P] : never;
+export type PathValue<T, P extends Path<T, D>, D extends string = '.'> = P extends `${infer K}${D}${infer Rest}` ? K extends keyof T ? Rest extends Path<T[K], D> ? PathValue<T[K], Rest, D> : never : never : P extends keyof T ? T[P] : never;
 /** Check if path has a primitive end value and return only the union of end paths */
-export declare type PathToLiteral<T, K extends Path<T, D>, D extends string = '.', Base extends string = ''> = PathValue<T, K, D> extends string | number ? K extends string | number ? K extends `${infer BasePath}${D}${Base}` ? BasePath : K : never : never;
+export type PathToLiteral<T, K extends Path<T, D>, D extends string = '.', Base extends string = ''> = PathValue<T, K, D> extends string | number ? K extends string | number ? K extends `${infer BasePath}${D}${Base}` ? BasePath : K : never : never;
 /**
  * Reduce all paths to a single map of paths with primitive values removing all extra non stateful paths
  * { path: { sub: 1 } } => { 'path-sub': 1 }
  *
  */
-export declare type LiteralPaths<T extends Record<string | number, any>, D extends string = '.', Base extends string = ''> = {
+export type LiteralPaths<T extends Record<string | number, any>, D extends string = '.', Base extends string = ''> = {
     [K in Path<T, D> as PathToLiteral<T, K, D, Base>]: PathValue<T, PathToLiteral<T, K, D>, D>;
 };
 export declare function flattenScale<T extends Record<string | number, any>, P extends string>(object: T, path?: P): LiteralPaths<T, '-', '_'>;

package/dist/utils/serializeTokens.d.ts

@@ -3,10 +3,10 @@ import { CSSObject } from '../types/props';
 /**
  * Returns an type of any object with { key: 'var(--key) }
  */
-export declare type KeyAsVariable<T extends Record<string, any>, Prefix extends string> = {
+export type KeyAsVariable<T extends Record<string, any>, Prefix extends string> = {
     [V in keyof T]: `var(--${Prefix}-${Extract<V, string>})`;
 };
-declare type SerializedTokensInput = Record<string, string | number | CSSObject | SerializedTokensInputRecursive>;
+type SerializedTokensInput = Record<string, string | number | CSSObject | SerializedTokensInputRecursive>;
 interface SerializedTokensInputRecursive {
     [i: number]: SerializedTokensInput;
     [i: string]: SerializedTokensInput;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@codecademy/variance",
   "description": "Constraint based CSS in JS for building scalable design systems",
-  "version": "0.21.1-alpha.d9da73.0",
+  "version": "0.21.1",
   "keywords": [
     "emotion",
     "css",
@@ -25,7 +25,7 @@
     "url": "git+https://github.com/Codecademy/gamut.git"
   },
   "scripts": {
-    "build": "nx build variance"
+    "build": "nx build @codecademy/variance"
   },
   "peerDependencies": {
     "@emotion/react": "*",
@@ -35,12 +35,5 @@
     "csstype": "^3.0.7",
     "lodash": "^4.17.5"
   },
-  "devDependencies": {
-    "@emotion/jest": "^11.3.0",
-    "@emotion/styled": "^11.3.0",
-    "@types/react-test-renderer": "^17.0.2",
-    "react": "^17.0.2",
-    "react-test-renderer": "^17.0.2"
-  },
-  "gitHead": "2dc9984fe01f9c4668d5dbd0bfd5b803c10519d5"
+  "gitHead": "baa23988e9eb59834cafd89bbfd7923dfe1039d9"
 }

package/dist/utils/__fixtures__/testConfig.js

@@ -1,153 +0,0 @@
-export var testConfig = {
-  textColor: {
-    property: 'color'
-  },
-  bg: {
-    property: 'backgroundColor'
-  },
-  borderColor: {
-    property: 'borderColor'
-  },
-  borderColorX: {
-    property: 'borderColor',
-    properties: ['borderLeftColor', 'borderRightColor'],
-    scale: 'colors'
-  },
-  borderColorY: {
-    property: 'borderColor',
-    properties: ['borderTopColor', 'borderBottomColor'],
-    scale: 'colors'
-  },
-  borderColorLeft: {
-    property: 'borderLeftColor'
-  },
-  borderColorRight: {
-    property: 'borderRightColor'
-  },
-  borderColorTop: {
-    property: 'borderTopColor'
-  },
-  borderColorBottom: {
-    property: 'borderBottomColor'
-  },
-  border: {
-    property: 'border'
-  },
-  borderX: {
-    property: 'border',
-    properties: ['borderLeft', 'borderRight']
-  },
-  borderY: {
-    property: 'border',
-    properties: ['borderTop', 'borderBottom']
-  },
-  borderTop: {
-    property: 'borderTop'
-  },
-  borderRight: {
-    property: 'borderRight'
-  },
-  borderBottom: {
-    property: 'borderBottom'
-  },
-  borderLeft: {
-    property: 'borderLeft'
-  },
-  borderWidth: {
-    property: 'borderWidth'
-  },
-  borderWidthX: {
-    property: 'borderWidth',
-    properties: ['borderLeftWidth', 'borderRightWidth']
-  },
-  borderWidthY: {
-    property: 'borderWidth',
-    properties: ['borderTopWidth', 'borderBottomWidth']
-  },
-  borderRadius: {
-    property: 'borderRadius'
-  },
-  borderRadiusLeft: {
-    property: 'borderRadius',
-    properties: ['borderTopLeftRadius', 'borderBottomLeftRadius']
-  },
-  borderRadiusTop: {
-    property: 'borderRadius',
-    properties: ['borderTopLeftRadius', 'borderTopRightRadius']
-  },
-  borderRadiusBottom: {
-    property: 'borderRadius',
-    properties: ['borderBottomLeftRadius', 'borderBottomRightRadius']
-  },
-  borderRadiusRight: {
-    property: 'borderRadius',
-    properties: ['borderTopRightRadius', 'borderBottomRightRadius']
-  },
-  borderStyle: {
-    property: 'borderStyle'
-  },
-  borderStyleX: {
-    property: 'borderStyle',
-    properties: ['borderLeftStyle', 'borderRightStyle']
-  },
-  borderStyleY: {
-    property: 'borderStyle',
-    properties: ['borderTopStyle', 'borderBottomStyle']
-  },
-  flex: {
-    property: 'flex'
-  },
-  flexBasis: {
-    property: 'flexBasis'
-  },
-  p: {
-    property: 'padding'
-  },
-  px: {
-    property: 'padding',
-    properties: ['paddingLeft', 'paddingRight'],
-    scale: 'spacing'
-  },
-  py: {
-    property: 'padding',
-    properties: ['paddingTop', 'paddingBottom'],
-    scale: 'spacing'
-  },
-  pt: {
-    property: 'paddingTop'
-  },
-  pb: {
-    property: 'paddingBottom'
-  },
-  pr: {
-    property: 'paddingRight'
-  },
-  pl: {
-    property: 'paddingLeft'
-  },
-  m: {
-    property: 'margin'
-  },
-  mx: {
-    property: 'margin',
-    properties: ['marginLeft', 'marginRight'],
-    scale: 'spacing'
-  },
-  my: {
-    property: 'margin',
-    properties: ['marginTop', 'marginBottom'],
-    scale: 'spacing'
-  },
-  mt: {
-    property: 'marginTop'
-  },
-  mb: {
-    property: 'marginBottom'
-  },
-  mr: {
-    property: 'marginRight'
-  },
-  ml: {
-    property: 'marginLeft'
-  }
-};