@sitecore/sc-contenthub-blok 0.0.90 → 1.0.1

package/node_modules/@emotion/react/src/{jsx-dev-runtime.js → jsx-dev-runtime.ts}

@@ -1,10 +1,20 @@
 import * as ReactJSXRuntimeDev from 'react/jsx-dev-runtime'
 import Emotion, { createEmotionProps } from './emotion-element'
 import { hasOwn } from './utils'
+import { Interpolation } from '@emotion/serialize'
+import { Theme } from './theming'
+export type { EmotionJSX as JSX } from './jsx-namespace'
 
 export const Fragment = ReactJSXRuntimeDev.Fragment
 
-export function jsxDEV(type, props, key, isStaticChildren, source, self) {
+export const jsxDEV: typeof ReactJSXRuntimeDev.jsxDEV = (
+  type,
+  props,
+  key,
+  isStaticChildren,
+  source,
+  self
+) => {
   if (!hasOwn.call(props, 'css')) {
     return ReactJSXRuntimeDev.jsxDEV(
       type,
@@ -18,7 +28,7 @@ export function jsxDEV(type, props, key, isStaticChildren, source, self) {
 
   return ReactJSXRuntimeDev.jsxDEV(
     Emotion,
-    createEmotionProps(type, props),
+    createEmotionProps(type, props as { css: Interpolation<Theme> }),
     key,
     isStaticChildren,
     source,

package/node_modules/@emotion/react/src/jsx-namespace.ts

@@ -0,0 +1,107 @@
+import 'react'
+import { Interpolation } from '@emotion/serialize'
+import { Theme } from './theming'
+
+type IsPreReact19 = 2 extends Parameters<React.FunctionComponent<any>>['length']
+  ? true
+  : false
+
+type WithConditionalCSSProp<P> = 'className' extends keyof P
+  ? string extends P['className' & keyof P]
+    ? { css?: Interpolation<Theme> }
+    : {}
+  : {}
+
+// unpack all here to avoid infinite self-referencing when defining our own JSX namespace for the pre-React 19 case
+
+// the IsPreReact19 and @ts-ignore comments are to allow @emotion/react to support three different cases of types
+// - pre-React 18.something which didn't have `React.JSX`
+// - React 18.something with `React.JSX`
+// - React 19 with `React.JSX` and no global `JSX`
+// we support both pre-React 19 cases by using the global `JSX` and with the React 19 types, we use `React.JSX`
+// to make this work, we need @ts-ignore comments to ignore references that are invalid
+// though note that the error types resulting from ignoring the errors will never be used
+// since the pre vs post React 19 conditional will pick the one that won't error
+
+// prettier-ignore
+/** @ts-ignore */
+type ReactJSXElement = true extends IsPreReact19 ? JSX.Element : React.JSX.Element
+
+// prettier-ignore
+/** @ts-ignore */
+type ReactJSXElementClass = true extends IsPreReact19 ? JSX.ElementClass : React.JSX.ElementClass
+
+// prettier-ignore
+/** @ts-ignore */
+type ReactJSXElementAttributesProperty = true extends IsPreReact19 ? JSX.ElementAttributesProperty : React.JSX.ElementAttributesProperty
+
+// prettier-ignore
+/** @ts-ignore */
+type ReactJSXElementChildrenAttribute = true extends IsPreReact19 ? JSX.ElementChildrenAttribute : React.JSX.ElementChildrenAttribute
+
+// prettier-ignore
+/** @ts-ignore */
+type ReactJSXLibraryManagedAttributes<C, P> = true extends IsPreReact19 ? JSX.LibraryManagedAttributes<C, P> : React.JSX.LibraryManagedAttributes<C, P>
+
+// prettier-ignore
+/** @ts-ignore */
+type ReactJSXIntrinsicAttributes = true extends IsPreReact19 ? JSX.IntrinsicAttributes : React.JSX.IntrinsicAttributes
+
+// prettier-ignore
+/** @ts-ignore */
+type ReactJSXIntrinsicClassAttributes<T> = true extends IsPreReact19 ? JSX.IntrinsicClassAttributes<T> : React.JSX.IntrinsicClassAttributes<T>
+
+// prettier-ignore
+/** @ts-ignore */
+type ReactJSXIntrinsicElements = true extends IsPreReact19 ? JSX.IntrinsicElements : React.JSX.IntrinsicElements
+
+// based on the code from @types/react@18.2.8
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/3197efc097d522c4bf02b94e1a0766d007d6cdeb/types/react/index.d.ts#LL3204C13-L3204C13
+// prettier-ignore
+/** @ts-ignore */
+type ReactJSXElementType = true extends IsPreReact19 ? string | React.JSXElementConstructor<any> : React.JSX.ElementType
+
+export namespace ReactJSX {
+  export type ElementType = ReactJSXElementType
+  export interface Element extends ReactJSXElement {}
+  export interface ElementClass extends ReactJSXElementClass {}
+  export interface ElementAttributesProperty
+    extends ReactJSXElementAttributesProperty {}
+  export interface ElementChildrenAttribute
+    extends ReactJSXElementChildrenAttribute {}
+
+  export type LibraryManagedAttributes<C, P> = ReactJSXLibraryManagedAttributes<
+    C,
+    P
+  >
+
+  export interface IntrinsicAttributes extends ReactJSXIntrinsicAttributes {}
+  export interface IntrinsicClassAttributes<T>
+    extends ReactJSXIntrinsicClassAttributes<T> {}
+
+  export type IntrinsicElements = ReactJSXIntrinsicElements
+}
+
+export namespace EmotionJSX {
+  export type ElementType = ReactJSXElementType
+  export interface Element extends ReactJSXElement {}
+  export interface ElementClass extends ReactJSXElementClass {}
+  export interface ElementAttributesProperty
+    extends ReactJSXElementAttributesProperty {}
+  export interface ElementChildrenAttribute
+    extends ReactJSXElementChildrenAttribute {}
+
+  export type LibraryManagedAttributes<C, P> = P extends unknown
+    ? WithConditionalCSSProp<P> & ReactJSXLibraryManagedAttributes<C, P>
+    : never
+
+  export interface IntrinsicAttributes extends ReactJSXIntrinsicAttributes {}
+  export interface IntrinsicClassAttributes<T>
+    extends ReactJSXIntrinsicClassAttributes<T> {}
+
+  export type IntrinsicElements = {
+    [K in keyof ReactJSXIntrinsicElements]: ReactJSXIntrinsicElements[K] & {
+      css?: Interpolation<Theme>
+    }
+  }
+}

package/node_modules/@emotion/react/src/jsx-runtime.ts

@@ -0,0 +1,32 @@
+import * as ReactJSXRuntime from 'react/jsx-runtime'
+import Emotion, { createEmotionProps } from './emotion-element'
+import { hasOwn } from './utils'
+import { Interpolation } from '@emotion/serialize'
+import { Theme } from './theming'
+export type { EmotionJSX as JSX } from './jsx-namespace'
+
+export const Fragment = ReactJSXRuntime.Fragment
+
+export const jsx: typeof ReactJSXRuntime.jsx = (type, props, key) => {
+  if (!hasOwn.call(props, 'css')) {
+    return ReactJSXRuntime.jsx(type, props, key)
+  }
+
+  return ReactJSXRuntime.jsx(
+    Emotion,
+    createEmotionProps(type, props as { css: Interpolation<Theme> }),
+    key
+  )
+}
+
+export const jsxs: typeof ReactJSXRuntime.jsxs = (type, props, key) => {
+  if (!hasOwn.call(props, 'css')) {
+    return ReactJSXRuntime.jsxs(type, props, key)
+  }
+
+  return ReactJSXRuntime.jsxs(
+    Emotion,
+    createEmotionProps(type, props as { css: Interpolation<Theme> }),
+    key
+  )
+}

package/node_modules/@emotion/react/src/jsx.ts

@@ -0,0 +1,45 @@
+import * as React from 'react'
+import Emotion, { createEmotionProps } from './emotion-element'
+import { EmotionJSX } from './jsx-namespace'
+import { hasOwn } from './utils'
+
+export const jsx: typeof React.createElement = function (
+  type: any,
+  props: any
+): any {
+  // eslint-disable-next-line prefer-rest-params
+  let args: any = arguments
+
+  if (props == null || !hasOwn.call(props, 'css')) {
+    return React.createElement.apply(undefined, args)
+  }
+
+  let argsLength = args.length
+  let createElementArgArray: any = new Array(argsLength)
+  createElementArgArray[0] = Emotion
+  createElementArgArray[1] = createEmotionProps(type, props)
+
+  for (let i = 2; i < argsLength; i++) {
+    createElementArgArray[i] = args[i]
+  }
+
+  return React.createElement.apply(null, createElementArgArray)
+}
+export namespace jsx {
+  export namespace JSX {
+    export type ElementType = EmotionJSX.ElementType
+    export interface Element extends EmotionJSX.Element {}
+    export interface ElementClass extends EmotionJSX.ElementClass {}
+    export interface ElementAttributesProperty
+      extends EmotionJSX.ElementAttributesProperty {}
+    export interface ElementChildrenAttribute
+      extends EmotionJSX.ElementChildrenAttribute {}
+    export type LibraryManagedAttributes<C, P> =
+      EmotionJSX.LibraryManagedAttributes<C, P>
+    export interface IntrinsicAttributes
+      extends EmotionJSX.IntrinsicAttributes {}
+    export interface IntrinsicClassAttributes<T>
+      extends EmotionJSX.IntrinsicClassAttributes<T> {}
+    export type IntrinsicElements = EmotionJSX.IntrinsicElements
+  }
+}

package/node_modules/@emotion/react/src/keyframes.ts

@@ -0,0 +1,27 @@
+import { CSSInterpolation } from '@emotion/serialize'
+import css from './css'
+
+type Keyframes = {
+  name: string
+  styles: string
+  anim: 1
+  toString: () => string
+} & string
+
+export function keyframes(
+  template: TemplateStringsArray,
+  ...args: CSSInterpolation[]
+): Keyframes
+export function keyframes(...args: CSSInterpolation[]): Keyframes
+export function keyframes(...args: CSSInterpolation[]) {
+  let insertable = css(...args)
+  const name = `animation-${insertable.name}`
+  return {
+    name,
+    styles: `@keyframes ${name}{${insertable.styles}}`,
+    anim: 1,
+    toString() {
+      return `_EMO_${this.name}_${this.styles}_EMO_`
+    }
+  }
+}

package/node_modules/@emotion/react/src/{theming.js → theming.tsx}

@@ -2,8 +2,25 @@ import * as React from 'react'
 import weakMemoize from '@emotion/weak-memoize'
 import isDevelopment from '#is-development'
 import hoistNonReactStatics from './_isolated-hnrs'
+import { DistributiveOmit, PropsOf } from './types'
 
-export const ThemeContext = /* #__PURE__ */ React.createContext({})
+// tslint:disable-next-line: no-empty-interface
+export interface Theme {}
+
+export interface ThemeProviderProps {
+  theme: Partial<Theme> | ((outerTheme: Theme) => Theme)
+  children: React.ReactNode
+}
+
+export interface ThemeProvider {
+  (props: ThemeProviderProps): React.ReactElement
+}
+
+export type WithTheme<P, T> = P extends { theme: infer Theme }
+  ? P & { theme: Exclude<Theme, undefined> }
+  : P & { theme: T }
+
+export const ThemeContext = /* #__PURE__ */ React.createContext({} as Theme)
 if (isDevelopment) {
   ThemeContext.displayName = 'EmotionThemeContext'
 }
@@ -11,9 +28,9 @@ if (isDevelopment) {
 export const useTheme = () => React.useContext(ThemeContext)
 
 const getTheme = (
-  outerTheme /*: Object */,
-  theme /*: Object | (Object => Object) */
-) => {
+  outerTheme: Theme,
+  theme: Partial<Theme> | ((theme: Theme) => Theme)
+): Theme => {
   if (typeof theme === 'function') {
     const mergedTheme = theme(outerTheme)
     if (
@@ -40,20 +57,18 @@ const getTheme = (
   return { ...outerTheme, ...theme }
 }
 
-let createCacheWithTheme = /* #__PURE__ */ weakMemoize(outerTheme => {
-  return weakMemoize(theme => {
+let createCacheWithTheme = /* #__PURE__ */ weakMemoize((outerTheme: Theme) => {
+  return weakMemoize((theme: Partial<Theme> | ((theme: Theme) => Theme)) => {
     return getTheme(outerTheme, theme)
   })
 })
 
-/*
-type ThemeProviderProps = {
-  theme: Object | (Object => Object),
-  children: React.Node
+export interface ThemeProviderProps {
+  theme: Partial<Theme> | ((outerTheme: Theme) => Theme)
+  children: React.ReactNode
 }
-*/
 
-export const ThemeProvider = (props /*: ThemeProviderProps */) => {
+export const ThemeProvider = (props: ThemeProviderProps) => {
   let theme = React.useContext(ThemeContext)
 
   if (props.theme !== theme) {
@@ -66,16 +81,23 @@ export const ThemeProvider = (props /*: ThemeProviderProps */) => {
   )
 }
 
-export function withTheme /* <Config: {}> */(
-  Component /*: React.AbstractComponent<Config> */
-) /*: React.AbstractComponent<$Diff<Config, { theme: Object }>> */ {
+export function withTheme<
+  C extends React.ComponentType<React.ComponentProps<C>>
+>(
+  Component: C
+): React.ForwardRefExoticComponent<
+  DistributiveOmit<PropsOf<C>, 'theme'> & { theme?: Theme }
+>
+export function withTheme(
+  Component: React.ComponentType<any>
+): React.ForwardRefExoticComponent<any> {
   const componentName = Component.displayName || Component.name || 'Component'
-  let render = (props, ref) => {
+
+  let WithTheme = React.forwardRef(function render(props, ref) {
     let theme = React.useContext(ThemeContext)
 
     return <Component theme={theme} ref={ref} {...props} />
-  }
-  let WithTheme = React.forwardRef(render)
+  })
 
   WithTheme.displayName = `WithTheme(${componentName})`
 

package/node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.cjs.js

@@ -3,12 +3,12 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _extends = require('@babel/runtime/helpers/extends');
-var React = require('react');
-var isPropValid = require('@emotion/is-prop-valid');
 var react = require('@emotion/react');
-var utils = require('@emotion/utils');
 var serialize = require('@emotion/serialize');
 var useInsertionEffectWithFallbacks = require('@emotion/use-insertion-effect-with-fallbacks');
+var utils = require('@emotion/utils');
+var React = require('react');
+var isPropValid = require('@emotion/is-prop-valid');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
@@ -33,71 +33,26 @@ function _interopNamespace(e) {
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 var isPropValid__default = /*#__PURE__*/_interopDefault(isPropValid);
 
-/* import type {
-  ElementType,
-  StatelessFunctionalComponent,
-  AbstractComponent
-} from 'react' */
-/*
-export type Interpolations = Array<any>
-
-export type StyledElementType<Props> =
-  | string
-  | AbstractComponent<{ ...Props, className: string }, mixed>
-
-export type StyledOptions = {
-  label?: string,
-  shouldForwardProp?: string => boolean,
-  target?: string
-}
-
-export type StyledComponent<Props> = StatelessFunctionalComponent<Props> & {
-  defaultProps: any,
-  toString: () => string,
-  withComponent: (
-    nextTag: StyledElementType<Props>,
-    nextOptions?: StyledOptions
-  ) => StyledComponent<Props>
-}
-
-export type PrivateStyledComponent<Props> = StyledComponent<Props> & {
-  __emotion_real: StyledComponent<Props>,
-  __emotion_base: any,
-  __emotion_styles: any,
-  __emotion_forwardProp: any
-}
-*/
+var isDevelopment = false;
 
 var testOmitPropsOnStringTag = isPropValid__default["default"];
 
-var testOmitPropsOnComponent = function testOmitPropsOnComponent(key
-/*: string */
-) {
+var testOmitPropsOnComponent = function testOmitPropsOnComponent(key) {
   return key !== 'theme';
 };
 
-var getDefaultShouldForwardProp = function getDefaultShouldForwardProp(tag
-/*: ElementType */
-) {
+var getDefaultShouldForwardProp = function getDefaultShouldForwardProp(tag) {
   return typeof tag === 'string' && // 96 is one less than the char code
   // for "a" so this is checking that
   // it's a lowercase character
   tag.charCodeAt(0) > 96 ? testOmitPropsOnStringTag : testOmitPropsOnComponent;
 };
-var composeShouldForwardProps = function composeShouldForwardProps(tag
-/*: PrivateStyledComponent<any> */
-, options
-/*: StyledOptions | void */
-, isReal
-/*: boolean */
-) {
+var composeShouldForwardProps = function composeShouldForwardProps(tag, options, isReal) {
   var shouldForwardProp;
 
   if (options) {
     var optionsShouldForwardProp = options.shouldForwardProp;
-    shouldForwardProp = tag.__emotion_forwardProp && optionsShouldForwardProp ? function (propName
-    /*: string */
-    ) {
+    shouldForwardProp = tag.__emotion_forwardProp && optionsShouldForwardProp ? function (propName) {
       return tag.__emotion_forwardProp(propName) && optionsShouldForwardProp(propName);
     } : optionsShouldForwardProp;
   }
@@ -108,22 +63,6 @@ var composeShouldForwardProps = function composeShouldForwardProps(tag
 
   return shouldForwardProp;
 };
-/*
-export type CreateStyledComponent = <Props>(
-  ...args: Interpolations
-) => StyledComponent<Props>
-
-export type CreateStyled = {
-  <Props>(
-    tag: StyledElementType<Props>,
-    options?: StyledOptions
-  ): (...args: Interpolations) => StyledComponent<Props>,
-  [key: string]: CreateStyledComponent,
-  bind: () => CreateStyled
-}
-*/
-
-var isDevelopment = false;
 
 var Insertion = function Insertion(_ref) {
   var cache = _ref.cache,
@@ -137,15 +76,7 @@ var Insertion = function Insertion(_ref) {
   return null;
 };
 
-var createStyled
-/*: CreateStyled */
-= function createStyled
-/*: CreateStyled */
-(tag
-/*: any */
-, options
-/* ?: StyledOptions */
-) {
+var createStyled = function createStyled(tag, options) {
 
   var isReal = tag.__emotion_real === tag;
   var baseTag = isReal && tag.__emotion_base || tag;
@@ -160,9 +91,8 @@ var createStyled
   var shouldForwardProp = composeShouldForwardProps(tag, options, isReal);
   var defaultShouldForwardProp = shouldForwardProp || getDefaultShouldForwardProp(baseTag);
   var shouldUseAs = !defaultShouldForwardProp('as');
-  /* return function<Props>(): PrivateStyledComponent<Props> { */
-
   return function () {
+    // eslint-disable-next-line prefer-rest-params
     var args = arguments;
     var styles = isReal && tag.__emotion_styles !== undefined ? tag.__emotion_styles.slice(0) : [];
 
@@ -171,22 +101,22 @@ var createStyled
     }
 
     if (args[0] == null || args[0].raw === undefined) {
+      // eslint-disable-next-line prefer-spread
       styles.push.apply(styles, args);
     } else {
+      var templateStringsArr = args[0];
 
-      styles.push(args[0][0]);
+      styles.push(templateStringsArr[0]);
       var len = args.length;
       var i = 1;
 
       for (; i < len; i++) {
 
-        styles.push(args[i], args[0][i]);
+        styles.push(args[i], templateStringsArr[i]);
       }
     }
 
-    var Styled
-    /*: PrivateStyledComponent<Props> */
-    = react.withEmotionCache(function (props, cache, ref) {
+    var Styled = react.withEmotionCache(function (props, cache, ref) {
       var FinalTag = shouldUseAs && props.as || baseTag;
       var className = '';
       var classInterpolations = [];
@@ -254,14 +184,11 @@ var createStyled
       }
     });
 
-    Styled.withComponent = function (nextTag
-    /*: StyledElementType<Props> */
-    , nextOptions
-    /* ?: StyledOptions */
-    ) {
-      return createStyled(nextTag, _extends({}, options, nextOptions, {
+    Styled.withComponent = function (nextTag, nextOptions) {
+      var newStyled = createStyled(nextTag, _extends({}, options, nextOptions, {
         shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true)
-      })).apply(void 0, styles);
+      }));
+      return newStyled.apply(void 0, styles);
     };
 
     return Styled;