@edvisor/product-language 0.1.0

package/src/lib/foundations/shadows/components.tsx

@@ -0,0 +1,59 @@
+import styled from 'styled-components'
+import { Surface } from '../color-system'
+import { Padding } from '../spacing'
+import {
+  shadowSm,
+  shadow,
+  shadowMd,
+  shadowLg,
+  shadowXl,
+  shadow2Xl,
+  shadowInner,
+} from './shadows'
+
+const Container = styled.div`
+  width: 128px;
+  height: 128px;
+  background: ${Surface.Default};
+  display: flex;
+  flex-direction: row;
+  justify-content: center;
+  align-items: center;
+  padding: ${Padding.none};
+`
+
+const ShadowSm = styled(Container)`
+  ${shadowSm}
+`
+const Shadow = styled(Container)`
+  ${shadow}
+`
+
+const ShadowMd = styled(Container)`
+  ${shadowMd}
+`
+const ShadowLg = styled(Container)`
+  ${shadowLg}
+`
+
+const ShadowXl = styled(Container)`
+  ${shadowXl}
+`
+
+const Shadow2Xl = styled(Container)`
+  ${shadow2Xl}
+`
+
+const ShadowInner = styled(Container)`
+  ${shadowInner}
+`
+
+export {
+  ShadowSm,
+  Shadow,
+  ShadowLg,
+  ShadowMd,
+  ShadowXl,
+  Shadow2Xl,
+  ShadowInner,
+}

package/src/lib/foundations/shadows/index.ts

@@ -0,0 +1 @@
+export * from './shadows'

package/src/lib/foundations/shadows/shadows.stories.mdx

@@ -0,0 +1,71 @@
+import { Canvas, Meta } from '@storybook/addon-docs';
+import {
+  ShadowSm,
+  Shadow,
+  Shadow2Xl,
+  ShadowInner,
+  ShadowMd,
+  ShadowLg,
+  ShadowXl
+} from './components'
+
+<Meta title="Foundations/Shadows"/>
+
+# Shadows
+
+For more details, check out the guidelines on [Figma](https://www.figma.com/file/ue1CurHfZ426o2T2l8Dk64/UI-Library-(in-progress)?node-id=743%3A7913)
+
+## How to use
+
+```javascript
+// Import the shadow that we'd like to use.
+import {
+  shadowSm,
+} from './shadows';
+
+import styled from 'styled-components';
+
+// Add them to the styled strucute that you'd like to add the shadow
+const ShadowSm = styled.div`
+  ${shadowSm}
+`
+```
+
+## Examples
+
+<Canvas>
+  <ShadowSm>
+    .shadow-sm
+  </ShadowSm>
+  <Shadow>
+    .shadow
+  </Shadow>
+  <ShadowMd>
+    .shadow-md
+  </ShadowMd>
+  <ShadowLg>
+    .shadow-lg
+  </ShadowLg>
+  <ShadowXl>
+    .shadow-xl
+  </ShadowXl>
+  <Shadow2Xl>
+    .shadow-2xl
+  </Shadow2Xl>
+  <ShadowInner>
+    .shadow-inner
+  </ShadowInner>
+</Canvas>
+
+## List of Values
+
+| Name |
+| ---- |
+| `shadowSm` |
+| `shadow` |
+| `shadowMd` |
+| `shadowLg` |
+| `shadowXl` |
+| `shadow2Xl` |
+| `shadowInner` |
+

package/src/lib/foundations/shadows/shadows.tsx

@@ -0,0 +1,47 @@
+import { css } from 'styled-components'
+
+const shadowSm = css`
+  box-shadow: 0px 1px 2px rgba(0, 0, 0, 0.05);
+  border-radius: 6px;
+`
+
+const shadow = css`
+  box-shadow: 0px 1px 3px rgba(0, 0, 0, 0.1), 0px 1px 2px rgba(0, 0, 0, 0.06);
+  border-radius: 6px;
+`
+
+const shadowMd = css`
+  box-shadow: 0px 2px 10px rgba(0, 0, 0, 0.1);
+  border-radius: 6px;
+`
+
+const shadowLg = css`
+  box-shadow: 0px 10px 15px -3px rgba(0, 0, 0, 0.1), 0px 4px 6px -2px rgba(0, 0, 0, 0.05);
+  border-radius: 6px;
+`
+
+const shadowXl = css`
+  box-shadow: 0px 20px 25px -5px rgba(0, 0, 0, 0.1), 0px 10px 10px -5px rgba(0, 0, 0, 0.04);
+  border-radius: 6px;
+`
+
+const shadow2Xl = css`
+  box-shadow: 0px 25px 50px -12px rgba(0, 0, 0, 0.25);
+  border-radius: 6px;
+`
+
+const shadowInner = css`
+  box-shadow: inset 0px 2px 4px rgba(0, 0, 0, 0.06);
+  border-radius: 6px;
+`
+
+export {
+  shadowSm,
+  shadow,
+  shadowMd,
+  shadowLg,
+  shadowXl,
+  shadow2Xl,
+  shadowInner,
+}
+

package/src/lib/foundations/spacing/index.ts

@@ -0,0 +1 @@
+export * from './spacing-guidelines'

package/src/lib/foundations/spacing/spacing-guidelines.ts

@@ -0,0 +1,24 @@
+import { SPACING } from './spacing'
+
+export const Padding = {
+  none: 0,
+  xxxs: SPACING.Size2,
+  xxs: SPACING.Size4,
+  xs: SPACING.Size8,
+  s: SPACING.Size12,
+  m: SPACING.Size16,
+  l: SPACING.Size24,
+  xl: SPACING.Size32,
+} as const
+
+export const Margin = {
+  none: 0,
+  xxxs: SPACING.Size2,
+  xxs: SPACING.Size4,
+  xs: SPACING.Size8,
+  s: SPACING.Size12,
+  m: SPACING.Size16,
+  l: SPACING.Size24,
+  xl: SPACING.Size32,
+  xxl: SPACING.Size64,
+} as const

package/src/lib/foundations/spacing/spacing.stories.mdx

@@ -0,0 +1,51 @@
+import { Meta, Description } from '@storybook/addon-docs';
+
+
+<Meta title="Foundations/Spacing" />
+
+# Spacing System
+
+All spacing for components and typography is done in increments of 8 pixels.
+This forms the basic unit of measurement for spacing.
+
+For more details, check out the guidelines on [Figma](https://www.figma.com/file/ue1CurHfZ426o2T2l8Dk64/UI-Library-(in-progress)?node-id=388%3A364)
+
+## How to use
+
+```javascript
+import SPACING from './spacing'
+
+//get the token value
+SPACING.[`YOUR-VALUE-HERE`]
+```
+
+## When to use
+
+You can set this values from this props:
+
+- width
+- heigth
+- margin
+- padding
+
+
+## List of Values
+
+| Name | Value |
+| ---- | ----- |
+| `Size2` | 2px|
+| `Size4` | 4px|
+| `Size8` | 8px|
+| `Size12` | 12px|
+| `Size16` | 16px|
+| `Size24` | 24px|
+| `Size32` | 32px|
+| `Size64` | 64px|
+| `Size96` | 96px|
+| `Size128` | 128px|
+| `Size192` | 192px|
+| `Size256` | 256px|
+| `Size384` | 384px|
+| `Size512` | 512px|
+| `Size640` | 640px|
+| `Size768` | 768px|

package/src/lib/foundations/spacing/spacing.ts

@@ -0,0 +1,18 @@
+export enum SPACING {
+  Size2 = '2px',
+  Size4 = '4px',
+  Size8 = '8px',
+  Size12 = '12px',
+  Size16 = '16px',
+  Size24 = '24px',
+  Size32 = '32px',
+  Size64 = '64px',
+  Size96 = '96px',
+  Size128 = '128px',
+  Size192 = '192px',
+  Size256 = '256px',
+  Size384 = '384px',
+  Size512 = '512px',
+  Size640 = '640px',
+  Size768 = '768px',
+}

package/src/lib/foundations/typography/constants.ts

@@ -0,0 +1,25 @@
+
+export const enum FontWeight {
+  Regular = '400',
+  Medium = '500',
+  SemiBold = '600',
+}
+
+export const FontSize = {
+  a: '13px',
+  b: '14px',
+  c: '16px',
+  d: '18px',
+  e: '20px',
+  f: '28px',
+  g: '36px',
+} as const
+
+export const LineHeight = {
+  a: '16px',
+  b: '20px',
+  c: '24px',
+  d: '28px',
+  e: '32px',
+  f: '44px',
+} as const

package/src/lib/foundations/typography/index.tsx

@@ -0,0 +1 @@
+export * from './typography'

package/src/lib/foundations/typography/text-aspect-flags.ts

@@ -0,0 +1,54 @@
+import { bitwiseOr, MappedEnum, PropsWithChildren, RequireOnlyOne } from '@helpers'
+import { Text } from '../color-system'
+
+export const enum TextAspects {
+  default = 1,
+  subdued = 2,
+  light = 4,
+  critical = 8,
+  success = 16,
+  onPrimary = 32,
+  onCritical = 64,
+}
+
+type TextOptions<T> = MappedEnum<typeof TextAspects, T>
+
+function toTextAspect(n: number): TextAspects {
+  switch (n) {
+    case TextAspects.subdued: return TextAspects.subdued
+    case TextAspects.light: return TextAspects.light
+    case TextAspects.critical: return TextAspects.critical
+    case TextAspects.success: return TextAspects.success
+    case TextAspects.onPrimary: return TextAspects.onPrimary
+    case TextAspects.onCritical: return TextAspects.onCritical
+    default: return TextAspects.default
+  }
+}
+
+const TextAspectColors = {
+  [TextAspects.default]: Text.Default,
+  [TextAspects.subdued]: Text.Subdued,
+  [TextAspects.light]: Text.Light,
+  [TextAspects.onPrimary]: Text.OnPrimary,
+  [TextAspects.onCritical]: Text.OnPrimary,
+  [TextAspects.success]: Text.Success,
+  [TextAspects.critical]: Text.Critical,
+}
+
+export type ITextAspectProps = Partial<RequireOnlyOne<TextOptions<boolean>>> & PropsWithChildren
+
+export function getTextAspect(props: ITextAspectProps) {
+  return TextAspectColors[
+    toTextAspect(
+      bitwiseOr([
+        props.default,
+        props.subdued,
+        props.light,
+        props.critical,
+        props.success,
+        props.onPrimary,
+        props.onCritical,
+      ])
+    )
+  ]
+}

package/src/lib/foundations/typography/typography.tsx

@@ -0,0 +1,97 @@
+import { css } from 'styled-components'
+import { getTextAspect, ITextAspectProps } from './text-aspect-flags'
+import { FontWeight, FontSize, LineHeight } from './constants'
+import { is } from '@helpers'
+
+export type ITextProps = ITextAspectProps & { emphasis?: boolean }
+
+const LightText = css` 
+  color: ${getTextAspect({ light: true })};
+`
+
+const Base = css<ITextProps>`
+  color: ${(props) => getTextAspect(props)};
+  font-family: 'Inter';
+`
+
+const Display = css<ITextProps>`
+  ${Base}
+  font-weight: ${FontWeight.Regular};
+  font-size: ${FontSize.g};
+  line-height: ${LineHeight.f};
+`
+
+const Heading1 = css<ITextProps>`
+  ${Base}
+  font-weight: ${FontWeight.SemiBold};
+  font-size: ${FontSize.f};
+  line-height: ${LineHeight.e};
+`
+
+const Heading2 = css<ITextProps>`
+  ${Heading1}
+  font-size: ${FontSize.e};
+  line-height: ${LineHeight.d};
+`
+
+const Heading3 = css<ITextProps>`
+  ${Heading1}
+  font-size: ${FontSize.c};
+  line-height: ${LineHeight.c};
+`
+
+const Heading4 = css<ITextProps>`
+  ${Heading1}
+  font-size: ${FontSize.b};
+  line-height: ${LineHeight.b};
+`
+
+const BodyLarge = css<ITextProps>`
+  ${Base}
+  font-weight: ${({ emphasis }) => is(emphasis) ? FontWeight.SemiBold : FontWeight.Regular};
+  font-size: ${FontSize.d};
+  line-height: ${LineHeight.d};
+`
+
+const Body = css<ITextProps>`
+  ${BodyLarge}
+  font-weight: ${({ emphasis }) => is(emphasis) ? FontWeight.Medium : FontWeight.Regular};
+  font-size: ${FontSize.b};
+  line-height: ${LineHeight.b};
+`
+
+const Caption = css<ITextProps>`
+  ${BodyLarge}
+  font-size: ${FontSize.a};
+  line-height: ${LineHeight.a};
+`
+
+const Label1 = css<ITextProps>`
+  ${BodyLarge}
+  font-weight: ${({ emphasis }) => is(emphasis) ? FontWeight.Medium : FontWeight.Regular};
+  font-size: ${FontSize.b};
+  line-height: ${LineHeight.b};
+`
+
+const Label2 = css<ITextProps>`
+  ${BodyLarge}
+  font-size: ${FontSize.a};
+  line-height: ${LineHeight.a};
+`
+
+export const Typography = {
+  Display,
+  Heading1,
+  Heading2,
+  Heading3,
+  Heading4,
+  BodyLarge,
+  Body,
+  Caption,
+  Label1,
+  Label2,
+}
+
+export const _Typography = {
+  LightText,
+}

package/src/lib/helpers/generic-types.ts

@@ -0,0 +1,44 @@
+// eslint-disable-next-line no-restricted-syntax
+import React, { FC as FunctionComponent, ForwardRefExoticComponent, ForwardRefRenderFunction, PropsWithChildren as PWC, PropsWithoutRef, RefAttributes } from 'react'
+import { Slot } from './slots'
+
+/** @see https://stackoverflow.com/a/49725198/29182 */
+export type RequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<
+T,
+Exclude<keyof T, Keys>
+> &
+{
+  [K in Keys]-?: Required<Pick<T, K>> &
+    Partial<Record<Exclude<Keys, K>, undefined>>;
+}[Keys];
+
+export type MappedEnum<E, T> = {
+  [key in keyof E]: T;
+}
+
+export type Values<T> = T[keyof T];
+
+export type PropsWithChildren<T = unknown> = PWC<T>
+
+// Our FC type adds the ability to specify sub-components such as Slots
+// also, just good to wrap imports from 3rd parties in general
+export type FC<
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  P = {}, 
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  E extends { [x: symbol]: FunctionComponent<PropsWithChildren> | typeof Slot } = {}
+> = FunctionComponent<P> 
+  & { 
+    [key in keyof E]: E[key]
+  }
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type ExtensibleForwardRef<T, P = {}, E = {}> = ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>
+  & {
+    [key in keyof E]: E[key]
+  }
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function forwardRef<T, P = {}, E = {}>(render: ForwardRefRenderFunction<T, P>): ExtensibleForwardRef<T, P, E> {
+  return React.forwardRef(render) as ExtensibleForwardRef<T, P, E>
+}

package/src/lib/helpers/index.ts

@@ -0,0 +1,6 @@
+export * from './safe-navigation'
+export * from './slots'
+export * from './generic-types'
+export * from './numbers'
+export * from './nothing'
+export * from './strings'

package/src/lib/helpers/nothing.tsx

@@ -0,0 +1,18 @@
+import { FC, PropsWithChildren } from './generic-types'
+import { isDefined } from './safe-navigation'
+
+// eslint-disable-next-line no-null/no-null
+export const Nothing: FC = () => null
+
+export function maybeRender<T>(prop: T, JSX: JSX.Element) {
+  return isDefined(prop) && Boolean(prop) ? JSX : <Nothing />
+}
+
+interface IIfProps {
+  is: unknown
+}
+
+export const If: FC<PropsWithChildren<IIfProps>> = (props) => {
+  // eslint-disable-next-line react/jsx-no-useless-fragment
+  return maybeRender(props.is, <>{props.children}</>)
+}

package/src/lib/helpers/numbers.ts

@@ -0,0 +1,53 @@
+export type Hex = `#${string}`
+
+export function clamp(a: number, b: number, c: number) {
+  return Math.max(a, Math.min(b, c))
+}
+
+export function toHex(n: number, length: number): Hex {
+  return `#${n.toString(16).padStart(length, '0').toUpperCase()}`
+}
+
+export function concatHex(a: Hex, b: Hex): Hex {
+  return `#${a.slice(1) + b.slice(1)}`
+}
+
+/** given an array of boolean flags, bitwiseOr interprets them as an unsigned integer
+ * 
+ * ```ts
+ * bitwiseOr([false, true, false, true]) => 5 // 0b0101
+ * ```
+ * 
+ * This is useful for indexing into an enum:
+ * 
+ * ```ts
+ * const enum Level {
+ *   default = 0,
+ *   info = 0,
+ *   danger = 1,
+ *   warning = 2
+ * }
+ * 
+ * interface IProps {
+ *  info?: boolean
+ *  danger?: boolean
+ *  warning?: boolean
+ * }
+ * 
+ * function toLevel(n: number): Level {
+ *   switch (n) {
+ *     case Level.info: return Level.info
+ *     case Level.danger: return Level.danger
+ *     case Level.warning: return Level.warning
+ *     default: return Level.default
+ *   }
+ * }
+ * 
+ * const level = bitwiseOr([props.info, props.danger, props.warning])
+ * 
+ * const levelEnum = toLevel(level)
+ * ```
+*/
+export function bitwiseOr(flags: unknown[]): number {
+  return flags.reduce((mask: number, flag, i) => mask | (Number(flag) << i), 0)
+}

package/src/lib/helpers/safe-navigation.ts

@@ -0,0 +1,34 @@
+
+/** even though we have null disabled in the repo,
+ * I still would not want isNil to skip checking null
+ * it is for juuuuust in case a third party sends us a null
+ * or something, and the types are not correct
+ */
+
+/* eslint-disable no-null/no-null */
+/* eslint-disable @typescript-eslint/ban-types */
+
+export function isNil<T>(value: T | undefined | null): value is undefined | null {
+  return value === null || value === undefined
+}
+
+export function isDefined<T>(value: T | undefined | null): value is T {
+  return !isNil(value)
+}
+
+export function defaultTo<T>(value: T | undefined | null, fallback: T): T {
+  return isDefined(value) ? value : fallback
+}
+
+export function isEmpty<T extends { length: number }>(obj: T) {
+  return obj.length < 1
+}
+
+/** used for evaluating tri-state logic (true | false | undefined) */
+export function is (pred?: boolean): boolean {
+  return isDefined(pred) && pred
+}
+
+export function safeArray<T>(arr: T[] | undefined | null): T[] {
+  return isDefined(arr) ? arr : []
+}

package/src/lib/helpers/slots.tsx

@@ -0,0 +1,76 @@
+import { Children, PureComponent, ReactElement, ReactNode } from 'react'
+import { PropsWithChildren } from './generic-types'
+import { isDefined, isNil } from './safe-navigation'
+
+/** 
+ * @TODO these aren't quiiiiite right
+ * 
+ * They all say they return ReactNode but I feel like JSX.Element or something
+ * is more accurate? The child type needs to include _anything react can render_
+ * but it should also allow the caller to cloneElement on the results so that
+ * they can do stuff like
+ * 
+ * const sections = getSlots(Section, children)
+ *  .map((el, i) => i === 0 ? cloneElement(el, { first: true }) : el)
+ * 
+ * Right? I want this...
+ * */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isReactElement (obj?: any): obj is ReactElement {
+  // eslint-disable-next-line no-prototype-builtins
+  return isDefined(obj) && obj.hasOwnProperty('type')
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isSlotOfType = <T extends typeof Slot>(type: T) => (obj?: any): obj is T => {
+  return isDefined(obj) && isReactElement(obj) && (Object.getPrototypeOf(obj.type) === type || obj.type === type)
+}
+
+const findSlotByType = <T extends typeof Slot>(type: T, children?: ReactNode): ReactNode => {
+  return Children.toArray(children).find(isSlotOfType(type))
+}
+
+const filterSlotByType = <T extends typeof Slot>(type: T, children?: ReactNode): ReactNode[] => {
+  return Children.toArray(children).filter(isSlotOfType(type))
+}
+
+export class Slot<T = unknown> extends PureComponent<PropsWithChildren<T>> {
+  override render () {
+    return this.props.children
+  }
+}
+
+export function getChildren(children?: ReactNode): ReactNode[] {
+  return Children.toArray(children).filter((child) => !isSlotOfType(Slot)(child))
+}
+
+export function getSlots<T extends typeof Slot>(slot: T, children?: ReactNode): ReactNode[] {
+  const result = filterSlotByType(slot, children)
+
+  if (isNil(result)) {
+    return []
+  }
+
+  return result
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function hasProps (obj: any): obj is { props: { children: ReactNode }} {
+  // eslint-disable-next-line no-prototype-builtins
+  return isDefined(obj) && obj.hasOwnProperty('props')
+}
+
+export function getSlot<T extends typeof Slot>(slot: T, children?: ReactNode): ReactNode {
+  const result = findSlotByType(slot, children)
+
+  if (isNil(result)) {
+    return undefined
+  }
+
+  if (hasProps(result)) {
+    return result
+  }
+
+  return result
+}