decocms 4.113.3 → 4.113.4

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

@@ -0,0 +1,132 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,90 @@
+/* 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

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,77 @@
+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,
+}