decocms 4.161.2 → 4.162.0

package/dist/server/node_modules/css-to-react-native/src/__tests__/units.js

@@ -1,132 +0,0 @@
-import transformCss from '..'
-
-// List of units from:
-// https://developer.mozilla.org/en-US/docs/Web/CSS/length
-const lengthUnits = [
-  'ch',
-  'em',
-  'ex',
-  'rem',
-  'vh',
-  'vw',
-  'vmin',
-  'vmax',
-  'cm',
-  'mm',
-  'in',
-  'pc',
-  'pt',
-]
-
-lengthUnits.forEach(unit => {
-  const value = `2${unit}`
-
-  it('allows CSS length units in transformed values', () => {
-    expect(transformCss([['margin', value]])).toEqual({
-      marginTop: value,
-      marginRight: value,
-      marginBottom: value,
-      marginLeft: value,
-    })
-    expect(transformCss([['padding', value]])).toEqual({
-      paddingTop: value,
-      paddingRight: value,
-      paddingBottom: value,
-      paddingLeft: value,
-    })
-  })
-
-  it('allows CSS length units with 0 and unit', () => {
-    expect(transformCss([['padding', `0${unit}`]])).toEqual({
-      paddingTop: `0${unit}`,
-      paddingRight: `0${unit}`,
-      paddingBottom: `0${unit}`,
-      paddingLeft: `0${unit}`,
-    })
-  })
-
-  it('allows mixed units in transformed values', () => {
-    expect(transformCss([['margin', `10px ${value}`]])).toEqual({
-      marginTop: 10,
-      marginRight: value,
-      marginBottom: 10,
-      marginLeft: value,
-    })
-  })
-
-  it('allows units to be used with border shorthand property', () => {
-    expect(transformCss([['border', `#f00 ${value} dashed`]])).toEqual({
-      borderWidth: value,
-      borderColor: '#f00',
-      borderStyle: 'dashed',
-    })
-
-    expect(transformCss([['border', value]])).toEqual({
-      borderWidth: value,
-      borderColor: 'black',
-      borderStyle: 'solid',
-    })
-  })
-
-  it('allows units to be used with border-width', () => {
-    expect(transformCss([['border-width', `1px 2px ${value} 4px`]])).toEqual({
-      borderTopWidth: 1,
-      borderRightWidth: 2,
-      borderBottomWidth: value,
-      borderLeftWidth: 4,
-    })
-  })
-
-  it('allows units to be used with border-radius', () => {
-    expect(transformCss([['border-radius', `1px ${value} 3px 4px`]])).toEqual({
-      borderTopLeftRadius: 1,
-      borderTopRightRadius: value,
-      borderBottomRightRadius: 3,
-      borderBottomLeftRadius: 4,
-    })
-  })
-
-  it('allows units to be used with font-size', () => {
-    expect(transformCss([['font-size', value]])).toEqual({
-      fontSize: value,
-    })
-  })
-
-  it('allows units to be used with font shorthand property', () => {
-    expect(
-      transformCss([['font', `bold italic ${value}/${value} "Helvetica"`]])
-    ).toEqual({
-      fontFamily: 'Helvetica',
-      fontSize: value,
-      fontWeight: 'bold',
-      fontStyle: 'italic',
-      fontVariant: [],
-      lineHeight: value,
-    })
-  })
-
-  it('allows untis to be used with text-shadow ', () => {
-    expect(transformCss([['text-shadow', `10px ${value} red`]])).toEqual({
-      textShadowOffset: { width: 10, height: value },
-      textShadowRadius: 0,
-      textShadowColor: 'red',
-    })
-  })
-
-  it('allows untis to be used with box-shadow', () => {
-    expect(
-      transformCss([['box-shadow', `10px ${value} ${value} red`]])
-    ).toEqual({
-      shadowOffset: { width: 10, height: value },
-      shadowRadius: value,
-      shadowColor: 'red',
-      shadowOpacity: 1,
-    })
-  })
-})
-
-it('throws for unit that is not supported', () => {
-  expect(() => transformCss([['margin', '10ic']])).toThrow(
-    'Failed to parse declaration "margin: 10ic"'
-  )
-})

package/dist/server/node_modules/css-to-react-native/src/devPropertiesWithoutUnitsRegExp.js

@@ -1,19 +0,0 @@
-let propertiesWithoutUnits
-if (process.env.NODE_ENV !== 'production') {
-  propertiesWithoutUnits = [
-    'aspectRatio',
-    'elevation',
-    'flexGrow',
-    'flexShrink',
-    'opacity',
-    'shadowOpacity',
-    'zIndex',
-  ]
-}
-
-const devPropertiesWithUnitsRegExp =
-  propertiesWithoutUnits != null
-    ? new RegExp(propertiesWithoutUnits.join('|'))
-    : null
-
-export default devPropertiesWithUnitsRegExp

package/dist/server/node_modules/css-to-react-native/src/index.js

@@ -1,90 +0,0 @@
-/* eslint-disable no-param-reassign */
-import parse from 'postcss-value-parser'
-import camelizeStyleName from 'camelize'
-import transforms from './transforms/index'
-import devPropertiesWithoutUnitsRegExp from './devPropertiesWithoutUnitsRegExp'
-import TokenStream from './TokenStream'
-
-// Note if this is wrong, you'll need to change tokenTypes.js too
-const numberOrLengthRe = /^([+-]?(?:\d*\.)?\d+(?:e[+-]?\d+)?)(?:px)?$/i
-const numberOnlyRe = /^[+-]?(?:\d*\.\d*|[1-9]\d*)(?:e[+-]?\d+)?$/i
-const boolRe = /^true|false$/i
-const nullRe = /^null$/i
-const undefinedRe = /^undefined$/i
-
-// Undocumented export
-export const transformRawValue = (propName, value) => {
-  if (process.env.NODE_ENV !== 'production') {
-    const needsUnit = !devPropertiesWithoutUnitsRegExp.test(propName)
-    const isNumberWithoutUnit = numberOnlyRe.test(value)
-    if (needsUnit && isNumberWithoutUnit) {
-      // eslint-disable-next-line no-console
-      console.warn(`Expected style "${propName}: ${value}" to contain units`)
-    }
-    if (!needsUnit && value !== '0' && !isNumberWithoutUnit) {
-      // eslint-disable-next-line no-console
-      console.warn(`Expected style "${propName}: ${value}" to be unitless`)
-    }
-  }
-
-  const numberMatch = value.match(numberOrLengthRe)
-  if (numberMatch !== null) return Number(numberMatch[1])
-
-  const boolMatch = value.match(boolRe)
-  if (boolMatch !== null) return boolMatch[0].toLowerCase() === 'true'
-
-  const nullMatch = value.match(nullRe)
-  if (nullMatch !== null) return null
-
-  const undefinedMatch = value.match(undefinedRe)
-  if (undefinedMatch !== null) return undefined
-
-  return value
-}
-
-const baseTransformShorthandValue = (propName, value) => {
-  const ast = parse(value)
-  const tokenStream = new TokenStream(ast.nodes)
-  return transforms[propName](tokenStream)
-}
-
-const transformShorthandValue =
-  process.env.NODE_ENV === 'production'
-    ? baseTransformShorthandValue
-    : (propName, value) => {
-        try {
-          return baseTransformShorthandValue(propName, value)
-        } catch (e) {
-          throw new Error(`Failed to parse declaration "${propName}: ${value}"`)
-        }
-      }
-
-export const getStylesForProperty = (propName, inputValue, allowShorthand) => {
-  const isRawValue = allowShorthand === false || !(propName in transforms)
-  const value = inputValue.trim()
-
-  const propValues = isRawValue
-    ? { [propName]: transformRawValue(propName, value) }
-    : transformShorthandValue(propName, value)
-
-  return propValues
-}
-
-export const getPropertyName = propName => {
-  const isCustomProp = /^--\w+/.test(propName)
-  if (isCustomProp) {
-    return propName
-  }
-  return camelizeStyleName(propName)
-}
-
-export default (rules, shorthandBlacklist = []) =>
-  rules.reduce((accum, rule) => {
-    const propertyName = getPropertyName(rule[0])
-    const value = rule[1]
-    const allowShorthand = shorthandBlacklist.indexOf(propertyName) === -1
-    return Object.assign(
-      accum,
-      getStylesForProperty(propertyName, value, allowShorthand)
-    )
-  }, {})

package/dist/server/node_modules/css-to-react-native/src/tokenTypes.js

@@ -1,75 +0,0 @@
-import { stringify } from 'postcss-value-parser'
-import cssColorKeywords from 'css-color-keywords'
-
-const matchString = node => {
-  if (node.type !== 'string') return null
-  return node.value
-    .replace(/\\([0-9a-f]{1,6})(?:\s|$)/gi, (match, charCode) =>
-      String.fromCharCode(parseInt(charCode, 16))
-    )
-    .replace(/\\/g, '')
-}
-
-const hexColorRe = /^(#(?:[0-9a-f]{3,4}){1,2})$/i
-const cssFunctionNameRe = /^(rgba?|hsla?|hwb|lab|lch|gray|color)$/
-
-const matchColor = node => {
-  if (
-    node.type === 'word' &&
-    (hexColorRe.test(node.value) ||
-      node.value in cssColorKeywords ||
-      node.value === 'transparent')
-  ) {
-    return node.value
-  } else if (node.type === 'function' && cssFunctionNameRe.test(node.value)) {
-    return stringify(node)
-  }
-  return null
-}
-
-const noneRe = /^(none)$/i
-const autoRe = /^(auto)$/i
-const identRe = /(^-?[_a-z][_a-z0-9-]*$)/i
-// Note if these are wrong, you'll need to change index.js too
-const numberRe = /^([+-]?(?:\d*\.)?\d+(?:e[+-]?\d+)?)$/i
-// Note lengthRe is sneaky: you can omit units for 0
-const lengthRe = /^(0$|(?:[+-]?(?:\d*\.)?\d+(?:e[+-]?\d+)?)(?=px$))/i
-const unsupportedUnitRe = /^([+-]?(?:\d*\.)?\d+(?:e[+-]?\d+)?(ch|em|ex|rem|vh|vw|vmin|vmax|cm|mm|in|pc|pt))$/i
-const angleRe = /^([+-]?(?:\d*\.)?\d+(?:e[+-]?\d+)?(?:deg|rad))$/i
-const percentRe = /^([+-]?(?:\d*\.)?\d+(?:e[+-]?\d+)?%)$/i
-
-const noopToken = predicate => node => (predicate(node) ? '<token>' : null)
-
-const valueForTypeToken = type => node =>
-  node.type === type ? node.value : null
-
-export const regExpToken = (regExp, transform = String) => node => {
-  if (node.type !== 'word') return null
-
-  const match = node.value.match(regExp)
-  if (match === null) return null
-
-  const value = transform(match[1])
-
-  return value
-}
-
-export const SPACE = noopToken(node => node.type === 'space')
-export const SLASH = noopToken(
-  node => node.type === 'div' && node.value === '/'
-)
-export const COMMA = noopToken(
-  node => node.type === 'div' && node.value === ','
-)
-export const WORD = valueForTypeToken('word')
-export const NONE = regExpToken(noneRe)
-export const AUTO = regExpToken(autoRe)
-export const NUMBER = regExpToken(numberRe, Number)
-export const LENGTH = regExpToken(lengthRe, Number)
-export const UNSUPPORTED_LENGTH_UNIT = regExpToken(unsupportedUnitRe)
-export const ANGLE = regExpToken(angleRe, angle => angle.toLowerCase())
-export const PERCENT = regExpToken(percentRe)
-export const IDENT = regExpToken(identRe)
-export const STRING = matchString
-export const COLOR = matchColor
-export const LINE = regExpToken(/^(none|underline|line-through)$/i)

package/dist/server/node_modules/css-to-react-native/src/transforms/aspectRatio.js

@@ -1,12 +0,0 @@
-import { NUMBER, SLASH } from '../tokenTypes'
-
-export default tokenStream => {
-  let aspectRatio = tokenStream.expect(NUMBER)
-
-  if (tokenStream.hasTokens()) {
-    tokenStream.expect(SLASH)
-    aspectRatio /= tokenStream.expect(NUMBER)
-  }
-
-  return { aspectRatio }
-}

package/dist/server/node_modules/css-to-react-native/src/transforms/border.js

@@ -1,53 +0,0 @@
-import {
-  regExpToken,
-  NONE,
-  COLOR,
-  LENGTH,
-  UNSUPPORTED_LENGTH_UNIT,
-  SPACE,
-} from '../tokenTypes'
-
-const BORDER_STYLE = regExpToken(/^(solid|dashed|dotted)$/)
-
-const defaultBorderWidth = 1
-const defaultBorderColor = 'black'
-const defaultBorderStyle = 'solid'
-
-export default tokenStream => {
-  let borderWidth
-  let borderColor
-  let borderStyle
-
-  if (tokenStream.matches(NONE)) {
-    tokenStream.expectEmpty()
-    return { borderWidth: 0, borderColor: 'black', borderStyle: 'solid' }
-  }
-
-  let partsParsed = 0
-  while (partsParsed < 3 && tokenStream.hasTokens()) {
-    if (partsParsed !== 0) tokenStream.expect(SPACE)
-
-    if (
-      borderWidth === undefined &&
-      tokenStream.matches(LENGTH, UNSUPPORTED_LENGTH_UNIT)
-    ) {
-      borderWidth = tokenStream.lastValue
-    } else if (borderColor === undefined && tokenStream.matches(COLOR)) {
-      borderColor = tokenStream.lastValue
-    } else if (borderStyle === undefined && tokenStream.matches(BORDER_STYLE)) {
-      borderStyle = tokenStream.lastValue
-    } else {
-      tokenStream.throw()
-    }
-
-    partsParsed += 1
-  }
-
-  tokenStream.expectEmpty()
-
-  if (borderWidth === undefined) borderWidth = defaultBorderWidth
-  if (borderColor === undefined) borderColor = defaultBorderColor
-  if (borderStyle === undefined) borderStyle = defaultBorderStyle
-
-  return { borderWidth, borderColor, borderStyle }
-}

package/dist/server/node_modules/css-to-react-native/src/transforms/boxShadow.js

@@ -1,11 +0,0 @@
-import { parseShadow } from './util'
-
-export default tokenStream => {
-  const { offset, radius, color } = parseShadow(tokenStream)
-  return {
-    shadowOffset: offset,
-    shadowRadius: radius,
-    shadowColor: color,
-    shadowOpacity: 1,
-  }
-}

package/dist/server/node_modules/css-to-react-native/src/transforms/flex.js

@@ -1,65 +0,0 @@
-import {
-  NONE,
-  AUTO,
-  NUMBER,
-  LENGTH,
-  UNSUPPORTED_LENGTH_UNIT,
-  PERCENT,
-  SPACE,
-} from '../tokenTypes'
-
-const defaultFlexGrow = 1
-const defaultFlexShrink = 1
-const defaultFlexBasis = 0
-
-export default tokenStream => {
-  let flexGrow
-  let flexShrink
-  let flexBasis
-
-  if (tokenStream.matches(NONE)) {
-    tokenStream.expectEmpty()
-    return { flexGrow: 0, flexShrink: 0, flexBasis: 'auto' }
-  }
-
-  tokenStream.saveRewindPoint()
-  if (tokenStream.matches(AUTO) && !tokenStream.hasTokens()) {
-    return { flexGrow: 1, flexShrink: 1, flexBasis: 'auto' }
-  }
-  tokenStream.rewind()
-
-  let partsParsed = 0
-  while (partsParsed < 2 && tokenStream.hasTokens()) {
-    if (partsParsed !== 0) tokenStream.expect(SPACE)
-
-    if (flexGrow === undefined && tokenStream.matches(NUMBER)) {
-      flexGrow = tokenStream.lastValue
-
-      tokenStream.saveRewindPoint()
-      if (tokenStream.matches(SPACE) && tokenStream.matches(NUMBER)) {
-        flexShrink = tokenStream.lastValue
-      } else {
-        tokenStream.rewind()
-      }
-    } else if (
-      flexBasis === undefined &&
-      tokenStream.matches(LENGTH, UNSUPPORTED_LENGTH_UNIT, PERCENT)
-    ) {
-      flexBasis = tokenStream.lastValue
-    } else if (flexBasis === undefined && tokenStream.matches(AUTO)) {
-      flexBasis = 'auto'
-    } else {
-      tokenStream.throw()
-    }
-
-    partsParsed += 1
-  }
-
-  tokenStream.expectEmpty()
-
-  if (flexGrow === undefined) flexGrow = defaultFlexGrow
-  if (flexShrink === undefined) flexShrink = defaultFlexShrink
-  if (flexBasis === undefined) flexBasis = defaultFlexBasis
-
-  return { flexGrow, flexShrink, flexBasis }
-}

package/dist/server/node_modules/css-to-react-native/src/transforms/flexFlow.js

@@ -1,37 +0,0 @@
-import { regExpToken, SPACE } from '../tokenTypes'
-
-const FLEX_WRAP = regExpToken(/(nowrap|wrap|wrap-reverse)/)
-const FLEX_DIRECTION = regExpToken(/(row|row-reverse|column|column-reverse)/)
-
-const defaultFlexWrap = 'nowrap'
-const defaultFlexDirection = 'row'
-
-export default tokenStream => {
-  let flexWrap
-  let flexDirection
-
-  let partsParsed = 0
-  while (partsParsed < 2 && tokenStream.hasTokens()) {
-    if (partsParsed !== 0) tokenStream.expect(SPACE)
-
-    if (flexWrap === undefined && tokenStream.matches(FLEX_WRAP)) {
-      flexWrap = tokenStream.lastValue
-    } else if (
-      flexDirection === undefined &&
-      tokenStream.matches(FLEX_DIRECTION)
-    ) {
-      flexDirection = tokenStream.lastValue
-    } else {
-      tokenStream.throw()
-    }
-
-    partsParsed += 1
-  }
-
-  tokenStream.expectEmpty()
-
-  if (flexWrap === undefined) flexWrap = defaultFlexWrap
-  if (flexDirection === undefined) flexDirection = defaultFlexDirection
-
-  return { flexWrap, flexDirection }
-}

package/dist/server/node_modules/css-to-react-native/src/transforms/font.js

@@ -1,63 +0,0 @@
-import parseFontFamily from './fontFamily'
-import {
-  regExpToken,
-  SPACE,
-  LENGTH,
-  UNSUPPORTED_LENGTH_UNIT,
-  SLASH,
-} from '../tokenTypes'
-
-const NORMAL = regExpToken(/^(normal)$/)
-const STYLE = regExpToken(/^(italic)$/)
-const WEIGHT = regExpToken(/^([1-9]00|bold)$/)
-const VARIANT = regExpToken(/^(small-caps)$/)
-
-const defaultFontStyle = 'normal'
-const defaultFontWeight = 'normal'
-const defaultFontVariant = []
-
-export default tokenStream => {
-  let fontStyle
-  let fontWeight
-  let fontVariant
-  // let fontSize;
-  let lineHeight
-  // let fontFamily;
-
-  let numStyleWeightVariantMatched = 0
-  while (numStyleWeightVariantMatched < 3 && tokenStream.hasTokens()) {
-    if (tokenStream.matches(NORMAL)) {
-      /* pass */
-    } else if (fontStyle === undefined && tokenStream.matches(STYLE)) {
-      fontStyle = tokenStream.lastValue
-    } else if (fontWeight === undefined && tokenStream.matches(WEIGHT)) {
-      fontWeight = tokenStream.lastValue
-    } else if (fontVariant === undefined && tokenStream.matches(VARIANT)) {
-      fontVariant = [tokenStream.lastValue]
-    } else {
-      break
-    }
-
-    tokenStream.expect(SPACE)
-    numStyleWeightVariantMatched += 1
-  }
-
-  const fontSize = tokenStream.expect(LENGTH, UNSUPPORTED_LENGTH_UNIT)
-
-  if (tokenStream.matches(SLASH)) {
-    lineHeight = tokenStream.expect(LENGTH, UNSUPPORTED_LENGTH_UNIT)
-  }
-
-  tokenStream.expect(SPACE)
-
-  const { fontFamily } = parseFontFamily(tokenStream)
-
-  if (fontStyle === undefined) fontStyle = defaultFontStyle
-  if (fontWeight === undefined) fontWeight = defaultFontWeight
-  if (fontVariant === undefined) fontVariant = defaultFontVariant
-
-  const out = { fontStyle, fontWeight, fontVariant, fontSize, fontFamily }
-  if (lineHeight !== undefined) out.lineHeight = lineHeight
-
-  return out
-}

package/dist/server/node_modules/css-to-react-native/src/transforms/fontFamily.js

@@ -1,20 +0,0 @@
-import { SPACE, IDENT, STRING } from '../tokenTypes'
-
-export default tokenStream => {
-  let fontFamily
-
-  if (tokenStream.matches(STRING)) {
-    fontFamily = tokenStream.lastValue
-  } else {
-    fontFamily = tokenStream.expect(IDENT)
-    while (tokenStream.hasTokens()) {
-      tokenStream.expect(SPACE)
-      const nextIdent = tokenStream.expect(IDENT)
-      fontFamily += ` ${nextIdent}`
-    }
-  }
-
-  tokenStream.expectEmpty()
-
-  return { fontFamily }
-}

package/dist/server/node_modules/css-to-react-native/src/transforms/fontVariant.js

@@ -1,14 +0,0 @@
-import { SPACE, IDENT } from '../tokenTypes'
-
-export default tokenStream => {
-  const values = [tokenStream.expect(IDENT)]
-
-  while (tokenStream.hasTokens()) {
-    tokenStream.expect(SPACE)
-    values.push(tokenStream.expect(IDENT))
-  }
-
-  return {
-    fontVariant: values,
-  }
-}

package/dist/server/node_modules/css-to-react-native/src/transforms/index.js

@@ -1,77 +0,0 @@
-import {
-  AUTO,
-  COLOR,
-  LENGTH,
-  PERCENT,
-  UNSUPPORTED_LENGTH_UNIT,
-  WORD,
-} from '../tokenTypes'
-import aspectRatio from './aspectRatio'
-import border from './border'
-import boxShadow from './boxShadow'
-import flex from './flex'
-import flexFlow from './flexFlow'
-import font from './font'
-import fontFamily from './fontFamily'
-import fontVariant from './fontVariant'
-import placeContent from './placeContent'
-import textDecoration from './textDecoration'
-import textDecorationLine from './textDecorationLine'
-import textShadow from './textShadow'
-import transform from './transform'
-import { directionFactory, parseShadowOffset } from './util'
-
-const background = tokenStream => ({
-  backgroundColor: tokenStream.expect(COLOR),
-})
-const borderColor = directionFactory({
-  types: [COLOR],
-  prefix: 'border',
-  suffix: 'Color',
-})
-const borderRadius = directionFactory({
-  directions: ['TopLeft', 'TopRight', 'BottomRight', 'BottomLeft'],
-  prefix: 'border',
-  suffix: 'Radius',
-})
-const borderWidth = directionFactory({ prefix: 'border', suffix: 'Width' })
-const margin = directionFactory({
-  types: [LENGTH, UNSUPPORTED_LENGTH_UNIT, PERCENT, AUTO],
-  prefix: 'margin',
-})
-const padding = directionFactory({ prefix: 'padding' })
-
-const fontWeight = tokenStream => ({
-  fontWeight: tokenStream.expect(WORD), // Also match numbers as strings
-})
-const shadowOffset = tokenStream => ({
-  shadowOffset: parseShadowOffset(tokenStream),
-})
-const textShadowOffset = tokenStream => ({
-  textShadowOffset: parseShadowOffset(tokenStream),
-})
-
-export default {
-  aspectRatio,
-  background,
-  border,
-  borderColor,
-  borderRadius,
-  borderWidth,
-  boxShadow,
-  flex,
-  flexFlow,
-  font,
-  fontFamily,
-  fontVariant,
-  fontWeight,
-  margin,
-  padding,
-  placeContent,
-  shadowOffset,
-  textShadow,
-  textShadowOffset,
-  textDecoration,
-  textDecorationLine,
-  transform,
-}