@sitecore/sc-contenthub-blok 1.0.32 → 2.1.1

package/node_modules/@emotion/babel-plugin/src/index.js

@@ -1,314 +0,0 @@
-import {
-  createEmotionMacro,
-  transformers as vanillaTransformers
-} from './emotion-macro'
-import { createStyledMacro, styledTransformer } from './styled-macro'
-import coreMacro, {
-  transformers as coreTransformers,
-  transformCsslessArrayExpression,
-  transformCsslessObjectExpression
-} from './core-macro'
-import { getStyledOptions, createTransformerMacro } from './utils'
-
-const getCssExport = (reexported, importSource, mapping) => {
-  const cssExport = Object.keys(mapping).find(localExportName => {
-    const [packageName, exportName] = mapping[localExportName].canonicalImport
-    return packageName === '@emotion/react' && exportName === 'css'
-  })
-
-  if (!cssExport) {
-    throw new Error(
-      `You have specified that '${importSource}' re-exports '${reexported}' from '@emotion/react' but it doesn't also re-export 'css' from '@emotion/react', 'css' is necessary for certain optimisations, please re-export it from '${importSource}'`
-    )
-  }
-
-  return cssExport
-}
-
-let webStyledMacro = createStyledMacro({
-  importSource: '@emotion/styled/base',
-  originalImportSource: '@emotion/styled',
-  isWeb: true
-})
-let nativeStyledMacro = createStyledMacro({
-  importSource: '@emotion/native',
-  originalImportSource: '@emotion/native',
-  isWeb: false
-})
-let primitivesStyledMacro = createStyledMacro({
-  importSource: '@emotion/primitives',
-  originalImportSource: '@emotion/primitives',
-  isWeb: false
-})
-let vanillaEmotionMacro = createEmotionMacro('@emotion/css')
-
-let transformersSource = {
-  '@emotion/css': vanillaTransformers,
-  '@emotion/react': coreTransformers,
-  '@emotion/styled': {
-    default: [
-      styledTransformer,
-      { styledBaseImport: ['@emotion/styled/base', 'default'], isWeb: true }
-    ]
-  },
-  '@emotion/primitives': {
-    default: [styledTransformer, { isWeb: false }]
-  },
-  '@emotion/native': {
-    default: [styledTransformer, { isWeb: false }]
-  }
-}
-
-export const macros = {
-  core: coreMacro,
-  nativeStyled: nativeStyledMacro,
-  primitivesStyled: primitivesStyledMacro,
-  webStyled: webStyledMacro,
-  vanillaEmotion: vanillaEmotionMacro
-}
-
-/*
-export type BabelPath = any
-
-export type EmotionBabelPluginPass = any
-*/
-
-const AUTO_LABEL_VALUES = ['dev-only', 'never', 'always']
-
-export default function (babel, options) {
-  if (
-    options.autoLabel !== undefined &&
-    !AUTO_LABEL_VALUES.includes(options.autoLabel)
-  ) {
-    throw new Error(
-      `The 'autoLabel' option must be undefined, or one of the following: ${AUTO_LABEL_VALUES.map(
-        s => `"${s}"`
-      ).join(', ')}`
-    )
-  }
-
-  let t = babel.types
-  return {
-    name: '@emotion',
-    // https://github.com/babel/babel/blob/0c97749e0fe8ad845b902e0b23a24b308b0bf05d/packages/babel-plugin-syntax-jsx/src/index.ts#L9-L18
-    manipulateOptions(opts, parserOpts) {
-      const { plugins } = parserOpts
-
-      if (
-        plugins.some(p => {
-          const plugin = Array.isArray(p) ? p[0] : p
-          return plugin === 'typescript' || plugin === 'jsx'
-        })
-      ) {
-        return
-      }
-
-      plugins.push('jsx')
-    },
-    visitor: {
-      ImportDeclaration(path, state) {
-        const macro = state.pluginMacros[path.node.source.value]
-        // most of this is from https://github.com/kentcdodds/babel-plugin-macros/blob/main/src/index.js
-        if (macro === undefined) {
-          return
-        }
-        if (t.isImportNamespaceSpecifier(path.node.specifiers[0])) {
-          return
-        }
-        const imports = path.node.specifiers.map(s => ({
-          localName: s.local.name,
-          importedName:
-            s.type === 'ImportDefaultSpecifier' ? 'default' : s.imported.name
-        }))
-        let shouldExit = false
-        let hasReferences = false
-        const referencePathsByImportName = imports.reduce(
-          (byName, { importedName, localName }) => {
-            let binding = path.scope.getBinding(localName)
-            if (!binding) {
-              shouldExit = true
-              return byName
-            }
-            byName[importedName] = binding.referencePaths
-            hasReferences =
-              hasReferences || Boolean(byName[importedName].length)
-            return byName
-          },
-          {}
-        )
-        if (!hasReferences || shouldExit) {
-          return
-        }
-        /**
-         * Other plugins that run before babel-plugin-macros might use path.replace, where a path is
-         * put into its own replacement. Apparently babel does not update the scope after such
-         * an operation. As a remedy, the whole scope is traversed again with an empty "Identifier"
-         * visitor - this makes the problem go away.
-         *
-         * See: https://github.com/kentcdodds/import-all.macro/issues/7
-         */
-        state.file.scope.path.traverse({
-          Identifier() {}
-        })
-
-        macro({
-          path,
-          references: referencePathsByImportName,
-          state,
-          babel,
-          isEmotionCall: true,
-          isBabelMacrosCall: true
-        })
-      },
-      Program(path, state) {
-        let macros = {}
-        let jsxReactImports /*: Array<{
-          importSource: string,
-          export: string,
-          cssExport: string
-        }> */ = [
-          { importSource: '@emotion/react', export: 'jsx', cssExport: 'css' }
-        ]
-        state.jsxReactImport = jsxReactImports[0]
-        Object.keys(state.opts.importMap || {}).forEach(importSource => {
-          let value = state.opts.importMap[importSource]
-          let transformers = {}
-          Object.keys(value).forEach(localExportName => {
-            let { canonicalImport, ...options } = value[localExportName]
-            let [packageName, exportName] = canonicalImport
-            if (packageName === '@emotion/react' && exportName === 'jsx') {
-              jsxReactImports.push({
-                importSource,
-                export: localExportName,
-                cssExport: getCssExport('jsx', importSource, value)
-              })
-              return
-            }
-            let packageTransformers = transformersSource[packageName]
-
-            if (packageTransformers === undefined) {
-              throw new Error(
-                `There is no transformer for the export '${exportName}' in '${packageName}'`
-              )
-            }
-
-            let extraOptions
-
-            if (packageName === '@emotion/react' && exportName === 'Global') {
-              // this option is not supposed to be set in importMap
-              extraOptions = {
-                cssExport: getCssExport('Global', importSource, value)
-              }
-            } else if (
-              packageName === '@emotion/styled' &&
-              exportName === 'default'
-            ) {
-              // this is supposed to override defaultOptions value
-              // and let correct value to be set if coming in options
-              extraOptions = {
-                styledBaseImport: undefined
-              }
-            }
-
-            let [exportTransformer, defaultOptions] = Array.isArray(
-              packageTransformers[exportName]
-            )
-              ? packageTransformers[exportName]
-              : [packageTransformers[exportName]]
-
-            transformers[localExportName] = [
-              exportTransformer,
-              {
-                ...defaultOptions,
-                ...extraOptions,
-                ...options
-              }
-            ]
-          })
-          macros[importSource] = createTransformerMacro(transformers, {
-            importSource
-          })
-        })
-        state.pluginMacros = {
-          '@emotion/styled': webStyledMacro,
-          '@emotion/react': coreMacro,
-          '@emotion/primitives': primitivesStyledMacro,
-          '@emotion/native': nativeStyledMacro,
-          '@emotion/css': vanillaEmotionMacro,
-          ...macros
-        }
-
-        for (const node of path.node.body) {
-          if (t.isImportDeclaration(node)) {
-            let jsxReactImport = jsxReactImports.find(
-              thing =>
-                node.source.value === thing.importSource &&
-                node.specifiers.some(
-                  x =>
-                    t.isImportSpecifier(x) && x.imported.name === thing.export
-                )
-            )
-            if (jsxReactImport) {
-              state.jsxReactImport = jsxReactImport
-              break
-            }
-          }
-        }
-
-        if (state.opts.cssPropOptimization === false) {
-          state.transformCssProp = false
-        } else {
-          state.transformCssProp = true
-        }
-
-        if (state.opts.sourceMap === false) {
-          state.emotionSourceMap = false
-        } else {
-          state.emotionSourceMap = true
-        }
-      },
-      JSXAttribute(path, state) {
-        if (path.node.name.name !== 'css' || !state.transformCssProp) {
-          return
-        }
-
-        if (t.isJSXExpressionContainer(path.node.value)) {
-          if (t.isArrayExpression(path.node.value.expression)) {
-            transformCsslessArrayExpression({
-              state,
-              babel,
-              path
-            })
-          } else if (t.isObjectExpression(path.node.value.expression)) {
-            transformCsslessObjectExpression({
-              state,
-              babel,
-              path,
-              cssImport: state.jsxReactImport
-            })
-          }
-        }
-      },
-      CallExpression: {
-        exit(path /*: BabelPath */, state /*: EmotionBabelPluginPass */) {
-          try {
-            if (
-              path.node.callee &&
-              path.node.callee.property &&
-              path.node.callee.property.name === 'withComponent'
-            ) {
-              switch (path.node.arguments.length) {
-                case 1:
-                case 2: {
-                  path.node.arguments[1] = getStyledOptions(t, path, state)
-                }
-              }
-            }
-          } catch (e) {
-            throw path.buildCodeFrameError(e)
-          }
-        }
-      }
-    }
-  }
-}

package/node_modules/@emotion/babel-plugin/src/styled-macro.js

@@ -1,144 +0,0 @@
-import {
-  transformExpressionWithStyles,
-  getStyledOptions,
-  addImport,
-  createTransformerMacro
-} from './utils'
-
-const getReferencedSpecifier = (path, specifierName) => {
-  const specifiers = path.get('specifiers')
-  return specifierName === 'default'
-    ? specifiers.find(p => p.isImportDefaultSpecifier())
-    : specifiers.find(p => p.node.local.name === specifierName)
-}
-
-export let styledTransformer = (
-  {
-    state,
-    babel,
-    path,
-    importSource,
-    reference,
-    importSpecifierName,
-    options: { styledBaseImport, isWeb }
-  } /*: {
-  state: Object,
-  babel: Object,
-  path: any,
-  importSource: string,
-  importSpecifierName: string,
-  reference: Object,
-  options: { styledBaseImport?: [string, string], isWeb: boolean }
-} */
-) => {
-  let t = babel.types
-
-  let getStyledIdentifier = () => {
-    if (
-      !styledBaseImport ||
-      (styledBaseImport[0] === importSource &&
-        styledBaseImport[1] === importSpecifierName)
-    ) {
-      return t.cloneNode(reference.node)
-    }
-
-    if (path.node) {
-      const referencedSpecifier = getReferencedSpecifier(
-        path,
-        importSpecifierName
-      )
-
-      if (referencedSpecifier) {
-        referencedSpecifier.remove()
-      }
-
-      if (!path.get('specifiers').length) {
-        path.remove()
-      }
-    }
-
-    const [baseImportSource, baseSpecifierName] = styledBaseImport
-
-    return addImport(state, baseImportSource, baseSpecifierName, 'styled')
-  }
-  let createStyledComponentPath = null
-  if (
-    t.isMemberExpression(reference.parent) &&
-    reference.parent.computed === false
-  ) {
-    if (
-      // checks if the first character is lowercase
-      // becasue we don't want to transform the member expression if
-      // it's in primitives/native
-      reference.parent.property.name.charCodeAt(0) > 96
-    ) {
-      reference.parentPath.replaceWith(
-        t.callExpression(getStyledIdentifier(), [
-          t.stringLiteral(reference.parent.property.name)
-        ])
-      )
-    } else {
-      reference.replaceWith(getStyledIdentifier())
-    }
-
-    createStyledComponentPath = reference.parentPath
-  } else if (
-    reference.parentPath &&
-    t.isCallExpression(reference.parentPath) &&
-    reference.parent.callee === reference.node
-  ) {
-    reference.replaceWith(getStyledIdentifier())
-    createStyledComponentPath = reference.parentPath
-  }
-
-  if (!createStyledComponentPath) {
-    return
-  }
-
-  const styledCallLikeWithStylesPath = createStyledComponentPath.parentPath
-
-  let node = transformExpressionWithStyles({
-    path: styledCallLikeWithStylesPath,
-    state,
-    babel,
-    shouldLabel: false
-  })
-
-  if (node && isWeb) {
-    // we know the argument length will be 1 since that's the only time we will have a node since it will be static
-    styledCallLikeWithStylesPath.node.arguments[0] = node
-  }
-
-  styledCallLikeWithStylesPath.addComment('leading', '#__PURE__')
-
-  if (isWeb) {
-    createStyledComponentPath.node.arguments[1] = getStyledOptions(
-      t,
-      createStyledComponentPath,
-      state
-    )
-  }
-}
-
-export let createStyledMacro = (
-  {
-    importSource,
-    originalImportSource = importSource,
-    baseImportName = 'default',
-    isWeb
-  } /*: {
-  importSource: string,
-  originalImportSource?: string,
-  baseImportName?: string,
-  isWeb: boolean
-} */
-) =>
-  createTransformerMacro(
-    {
-      default: [
-        styledTransformer,
-        { styledBaseImport: [importSource, baseImportName], isWeb }
-      ]
-    },
-    { importSource: originalImportSource }
-  )

package/node_modules/@emotion/babel-plugin/src/utils/add-import.js

@@ -1,30 +0,0 @@
-import { addDefault, addNamed } from '@babel/helper-module-imports'
-
-export function addImport(
-  state,
-  importSource /*: string */,
-  importedSpecifier /*: string */,
-  nameHint /* ?: string */
-) {
-  let cacheKey = ['import', importSource, importedSpecifier].join(':')
-  if (state[cacheKey] === undefined) {
-    let importIdentifier
-    if (importedSpecifier === 'default') {
-      importIdentifier = addDefault(state.file.path, importSource, { nameHint })
-    } else {
-      importIdentifier = addNamed(
-        state.file.path,
-        importedSpecifier,
-        importSource,
-        {
-          nameHint
-        }
-      )
-    }
-    state[cacheKey] = importIdentifier.name
-  }
-  return {
-    type: 'Identifier',
-    name: state[cacheKey]
-  }
-}

package/node_modules/@emotion/babel-plugin/src/utils/create-node-env-conditional.js

@@ -1,14 +0,0 @@
-export default function createNodeEnvConditional(t, production, development) {
-  return t.conditionalExpression(
-    t.binaryExpression(
-      '===',
-      t.memberExpression(
-        t.memberExpression(t.identifier('process'), t.identifier('env')),
-        t.identifier('NODE_ENV')
-      ),
-      t.stringLiteral('production')
-    ),
-    production,
-    development
-  )
-}

package/node_modules/@emotion/babel-plugin/src/utils/get-styled-options.js

@@ -1,102 +0,0 @@
-import { getLabelFromPath } from './label'
-import { getTargetClassName } from './get-target-class-name'
-import createNodeEnvConditional from './create-node-env-conditional'
-
-const getKnownProperties = (t, node) =>
-  new Set(
-    node.properties
-      .filter(n => t.isObjectProperty(n) && !n.computed)
-      .map(n => (t.isIdentifier(n.key) ? n.key.name : n.key.value))
-  )
-
-const createObjectSpreadLike = (t, file, ...objs) =>
-  t.callExpression(file.addHelper('extends'), [t.objectExpression([]), ...objs])
-
-export let getStyledOptions = (t, path, state) => {
-  const autoLabel = state.opts.autoLabel || 'dev-only'
-
-  let args = path.node.arguments
-  let optionsArgument = args.length >= 2 ? args[1] : null
-
-  let prodProperties = []
-  let devProperties = null
-  let knownProperties =
-    optionsArgument && t.isObjectExpression(optionsArgument)
-      ? getKnownProperties(t, optionsArgument)
-      : new Set()
-
-  if (!knownProperties.has('target')) {
-    prodProperties.push(
-      t.objectProperty(
-        t.identifier('target'),
-        t.stringLiteral(getTargetClassName(state, t))
-      )
-    )
-  }
-
-  let label =
-    autoLabel !== 'never' && !knownProperties.has('label')
-      ? getLabelFromPath(path, state, t)
-      : null
-
-  if (label) {
-    const labelNode = t.objectProperty(
-      t.identifier('label'),
-      t.stringLiteral(label)
-    )
-    switch (autoLabel) {
-      case 'always':
-        prodProperties.push(labelNode)
-        break
-      case 'dev-only':
-        devProperties = [labelNode]
-        break
-    }
-  }
-
-  if (optionsArgument) {
-    // for some reason `.withComponent` transformer gets requeued
-    // so check if this has been already transpiled to avoid double wrapping
-    if (
-      t.isConditionalExpression(optionsArgument) &&
-      t.isBinaryExpression(optionsArgument.test) &&
-      t.buildMatchMemberExpression('process.env.NODE_ENV')(
-        optionsArgument.test.left
-      )
-    ) {
-      return optionsArgument
-    }
-    if (!t.isObjectExpression(optionsArgument)) {
-      const prodNode = createObjectSpreadLike(
-        t,
-        state.file,
-        t.objectExpression(prodProperties),
-        optionsArgument
-      )
-      return devProperties
-        ? createNodeEnvConditional(
-            t,
-            prodNode,
-            t.cloneNode(
-              createObjectSpreadLike(
-                t,
-                state.file,
-                t.objectExpression(prodProperties.concat(devProperties)),
-                optionsArgument
-              )
-            )
-          )
-        : prodNode
-    }
-
-    prodProperties.unshift(...optionsArgument.properties)
-  }
-
-  return devProperties
-    ? createNodeEnvConditional(
-        t,
-        t.objectExpression(prodProperties),
-        t.cloneNode(t.objectExpression(prodProperties.concat(devProperties)))
-      )
-    : t.objectExpression(prodProperties)
-}

package/node_modules/@emotion/babel-plugin/src/utils/get-target-class-name.js

@@ -1,51 +0,0 @@
-import findRoot from 'find-root'
-import memoize from '@emotion/memoize'
-import nodePath from 'path'
-import hashString from '@emotion/hash'
-import escapeRegexp from 'escape-string-regexp'
-
-let hashArray = (arr /*: Array<string> */) => hashString(arr.join(''))
-
-const unsafeRequire = require
-
-const getPackageRootPath = memoize(filename => findRoot(filename))
-
-const separator = new RegExp(escapeRegexp(nodePath.sep), 'g')
-
-const normalizePath = path => nodePath.normalize(path).replace(separator, '/')
-
-export function getTargetClassName(state, t) {
-  if (state.emotionTargetClassNameCount === undefined) {
-    state.emotionTargetClassNameCount = 0
-  }
-
-  const hasFilepath =
-    state.file.opts.filename && state.file.opts.filename !== 'unknown'
-  const filename = hasFilepath ? state.file.opts.filename : ''
-  // normalize the file path to ignore folder structure
-  // outside the current node project and arch-specific delimiters
-  let moduleName = ''
-  let rootPath = filename
-
-  try {
-    rootPath = getPackageRootPath(filename)
-    moduleName = unsafeRequire(rootPath + '/package.json').name
-  } catch (err) {}
-
-  const finalPath =
-    filename === rootPath ? 'root' : filename.slice(rootPath.length)
-
-  const positionInFile = state.emotionTargetClassNameCount++
-
-  const stuffToHash = [moduleName]
-
-  if (finalPath) {
-    stuffToHash.push(normalizePath(finalPath))
-  } else {
-    stuffToHash.push(state.file.code)
-  }
-
-  const stableClassName = `e${hashArray(stuffToHash)}${positionInFile}`
-
-  return stableClassName
-}

package/node_modules/@emotion/babel-plugin/src/utils/index.js

@@ -1,12 +0,0 @@
-export { getLabelFromPath } from './label'
-export { getSourceMap } from './source-maps'
-export { getTargetClassName } from './get-target-class-name'
-export { simplifyObject } from './object-to-string'
-export { transformExpressionWithStyles } from './transform-expression-with-styles'
-export { getStyledOptions } from './get-styled-options'
-export {
-  appendStringReturningExpressionToArguments,
-  joinStringLiterals
-} from './strings'
-export { addImport } from './add-import'
-export { createTransformerMacro } from './transformer-macro'