Socket
Socket
Sign inDemoInstall

@emotion/core

Package Overview
Dependencies
0
Maintainers
3
Versions
85
Alerts
File Explorer

Advanced tools

npm Scripts

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 11.0.0-next.9 to 11.0.0-next.10

6

CHANGELOG.md
# @emotion/core
## 11.0.0-next.10
### Major Changes
- [`b8476e08`](https://github.com/emotion-js/emotion/commit/b8476e08af4a2e8de94a112cb0daf6e8e4d56fe1) [#1600](https://github.com/emotion-js/emotion/pull/1600) Thanks [@mitchellhamilton](https://github.com/mitchellhamilton)! - Rename `@emotion/core` to `@emotion/react`. Please change any imports of `@emotion/core` to import `@emotion/react` or use the `@emotion/pkg-renaming` ESLint rule from `@emotion/eslint-plugin`.
## 11.0.0-next.9

@@ -4,0 +10,0 @@

492

dist/core.cjs.dev.js
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
var React = require('react');
var createCache = _interopDefault(require('@emotion/cache'));
var _extends = _interopDefault(require('@babel/runtime/helpers/extends'));
var weakMemoize = _interopDefault(require('@emotion/weak-memoize'));
var hoistNonReactStatics = _interopDefault(require('hoist-non-react-statics'));
var utils = require('@emotion/utils');
var serialize = require('@emotion/serialize');
var sheet = require('@emotion/sheet');
var isBrowser = typeof document !== 'undefined';
var EmotionCacheContext = React.createContext( // we're doing this to avoid preconstruct's dead code elimination in this one case
// because this module is primarily intended for the browser and node
// but it's also required in react native and similar environments sometimes
// and we could have a special build just for that
// but this is much easier and the native packages
// might use a different theme context in the future anyway
typeof HTMLElement !== 'undefined' ? createCache() : null);
var CacheProvider = EmotionCacheContext.Provider;
exports.withEmotionCache = function withEmotionCache(func) {
// $FlowFixMe
return React.forwardRef(function (props, ref) {
// the cache will never be null in the browser
var cache = React.useContext(EmotionCacheContext);
return func(props, cache, ref);
});
};
if (!isBrowser) {
exports.withEmotionCache = function withEmotionCache(func) {
return function (props) {
var cache = React.useContext(EmotionCacheContext);
if (cache === null) {
// yes, we're potentially creating this on every render
// it doesn't actually matter though since it's only on the server
// so there will only every be a single render
// that could change in the future because of suspense and etc. but for now,
// this works and i don't want to optimise for a future thing that we aren't sure about
cache = createCache();
return React.createElement(EmotionCacheContext.Provider, {
value: cache
}, func(props, cache));
} else {
return func(props, cache);
}
};
};
}
var ThemeContext = React.createContext({});
var useTheme = function useTheme() {
return React.useContext(ThemeContext);
};
var getTheme = function getTheme(outerTheme, theme) {
if (typeof theme === 'function') {
var mergedTheme = theme(outerTheme);
if (process.env.NODE_ENV !== 'production' && (mergedTheme == null || typeof mergedTheme !== 'object' || Array.isArray(mergedTheme))) {
throw new Error('[ThemeProvider] Please return an object from your theme function, i.e. theme={() => ({})}!');
}
return mergedTheme;
}
if (process.env.NODE_ENV !== 'production' && (theme == null || typeof theme !== 'object' || Array.isArray(theme))) {
throw new Error('[ThemeProvider] Please make your theme prop a plain object');
}
return _extends({}, outerTheme, {}, theme);
};
var createCacheWithTheme = weakMemoize(function (outerTheme) {
return weakMemoize(function (theme) {
return getTheme(outerTheme, theme);
});
});
var ThemeProvider = function ThemeProvider(props) {
var theme = React.useContext(ThemeContext);
if (props.theme !== theme) {
theme = createCacheWithTheme(theme)(props.theme);
}
return React.createElement(ThemeContext.Provider, {
value: theme
}, props.children);
};
function withTheme(Component) {
var componentName = Component.displayName || Component.name || 'Component';
var render = function render(props, ref) {
var theme = React.useContext(ThemeContext);
return React.createElement(Component, _extends({
theme: theme,
ref: ref
}, props));
}; // $FlowFixMe
var WithTheme = React.forwardRef(render);
WithTheme.displayName = "WithTheme(" + componentName + ")";
return hoistNonReactStatics(WithTheme, Component);
}
// thus we only need to replace what is a valid character for JS, but not for CSS
var sanitizeIdentifier = function sanitizeIdentifier(identifier) {
return identifier.replace(/\$/g, '-');
};
var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
var labelPropName = '__EMOTION_LABEL_PLEASE_DO_NOT_USE__';
var hasOwnProperty = Object.prototype.hasOwnProperty;
var Emotion = exports.withEmotionCache(function (props, cache, ref) {
var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
// not passing the registered cache to serializeStyles because it would
// make certain babel optimisations not possible
if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
cssProp = cache.registered[cssProp];
}
var type = props[typePropName];
var registeredStyles = [cssProp];
var className = '';
if (typeof props.className === 'string') {
className = utils.getRegisteredStyles(cache.registered, registeredStyles, props.className);
} else if (props.className != null) {
className = props.className + " ";
}
var serialized = serialize.serializeStyles(registeredStyles, undefined, typeof cssProp === 'function' || Array.isArray(cssProp) ? React.useContext(ThemeContext) : undefined);
if (process.env.NODE_ENV !== 'production' && serialized.name.indexOf('-') === -1) {
var labelFromStack = props[labelPropName];
if (labelFromStack) {
serialized = serialize.serializeStyles([serialized, 'label:' + labelFromStack + ';']);
}
}
var rules = utils.insertStyles(cache, serialized, typeof type === 'string');
className += cache.key + "-" + serialized.name;
var newProps = {};
for (var key in props) {
if (hasOwnProperty.call(props, key) && key !== 'css' && key !== typePropName && (process.env.NODE_ENV === 'production' || key !== labelPropName)) {
newProps[key] = props[key];
}
}
newProps.ref = ref;
newProps.className = className;
var ele = React.createElement(type, newProps);
if (!isBrowser && rules !== undefined) {
var _ref;
var serializedNames = serialized.name;
var next = serialized.next;
while (next !== undefined) {
serializedNames += ' ' + next.name;
next = next.next;
}
return React.createElement(React.Fragment, null, React.createElement("style", (_ref = {}, _ref["data-emotion-" + cache.key] = serializedNames, _ref.dangerouslySetInnerHTML = {
__html: rules
}, _ref.nonce = cache.sheet.nonce, _ref)), ele);
}
return ele;
});
if (process.env.NODE_ENV !== 'production') {
Emotion.displayName = 'EmotionCssPropInternal';
} // $FlowFixMe
var jsx = function jsx(type, props) {
var args = arguments;
if (props == null || !hasOwnProperty.call(props, 'css')) {
// $FlowFixMe
return React.createElement.apply(undefined, args);
}
if (process.env.NODE_ENV !== 'production' && typeof props.css === 'string' && // check if there is a css declaration
props.css.indexOf(':') !== -1) {
throw new Error("Strings are not allowed as css prop values, please wrap it in a css template literal from '@emotion/core' like this: css`" + props.css + "`");
}
var argsLength = args.length;
var createElementArgArray = new Array(argsLength);
createElementArgArray[0] = Emotion;
var newProps = {};
for (var key in props) {
if (hasOwnProperty.call(props, key)) {
newProps[key] = props[key];
}
}
newProps[typePropName] = type;
if (process.env.NODE_ENV !== 'production') {
var error = new Error();
if (error.stack) {
// chrome
var match = error.stack.match(/at (?:Object\.|)jsx.*\n\s+at ([A-Z][A-Za-z$]+) /);
if (!match) {
// safari and firefox
match = error.stack.match(/^.*\n([A-Z][A-Za-z$]+)@/);
}
if (match) {
newProps[labelPropName] = sanitizeIdentifier(match[1]);
}
}
}
createElementArgArray[1] = newProps;
for (var i = 2; i < argsLength; i++) {
createElementArgArray[i] = args[i];
} // $FlowFixMe
return React.createElement.apply(null, createElementArgArray);
};
var warnedAboutCssPropForGlobal = false; // maintain place over rerenders.
// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
// initial client-side render from SSR, use place of hydrating tag
var Global =
/* #__PURE__ */
exports.withEmotionCache(function (props, cache) {
if (process.env.NODE_ENV !== 'production' && !warnedAboutCssPropForGlobal && ( // check for className as well since the user is
// probably using the custom createElement which
// means it will be turned into a className prop
// $FlowFixMe I don't really want to add it to the type since it shouldn't be used
props.className || props.css)) {
console.error("It looks like you're using the css prop on Global, did you mean to use the styles prop instead?");
warnedAboutCssPropForGlobal = true;
}
var styles = props.styles;
var serialized = serialize.serializeStyles([styles], undefined, typeof styles === 'function' || Array.isArray(styles) ? React.useContext(ThemeContext) : undefined);
if (!isBrowser) {
var _ref;
var serializedNames = serialized.name;
var serializedStyles = serialized.styles;
var next = serialized.next;
while (next !== undefined) {
serializedNames += ' ' + next.name;
serializedStyles += next.styles;
next = next.next;
}
var shouldCache = cache.compat === true;
var rules = cache.insert("", {
name: serializedNames,
styles: serializedStyles
}, cache.sheet, shouldCache);
if (shouldCache) {
return null;
}
return React.createElement("style", (_ref = {}, _ref["data-emotion-" + cache.key] = serializedNames, _ref.dangerouslySetInnerHTML = {
__html: rules
}, _ref.nonce = cache.sheet.nonce, _ref));
} // yes, i know these hooks are used conditionally
// but it is based on a constant that will never change at runtime
// it's effectively like having two implementations and switching them out
// so it's not actually breaking anything
var sheetRef = React.useRef();
React.useLayoutEffect(function () {
var sheet$1 = new sheet.StyleSheet({
key: cache.key + "-global",
nonce: cache.sheet.nonce,
container: cache.sheet.container
}); // $FlowFixMe
var node = document.querySelector("style[data-emotion-" + cache.key + "=\"" + serialized.name + "\"]");
if (node !== null) {
sheet$1.tags.push(node);
}
if (cache.sheet.tags.length) {
sheet$1.before = cache.sheet.tags[0];
}
sheetRef.current = sheet$1;
return function () {
sheet$1.flush();
};
}, [cache]);
React.useLayoutEffect(function () {
if (serialized.next !== undefined) {
// insert keyframes
utils.insertStyles(cache, serialized.next, true);
}
var sheet = sheetRef.current;
if (sheet.tags.length) {
// if this doesn't exist then it will be null so the style element will be appended
var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;
sheet.before = element;
sheet.flush();
}
cache.insert("", serialized, sheet, false);
}, [cache, serialized.name]);
return null;
});
function css() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
return serialize.serializeStyles(args);
}
var keyframes = function keyframes() {
var insertable = css.apply(void 0, arguments);
var name = "animation-" + insertable.name; // $FlowFixMe
return {
name: name,
styles: "@keyframes " + name + "{" + insertable.styles + "}",
anim: 1,
toString: function toString() {
return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
}
};
};
var classnames = function classnames(args) {
var len = args.length;
var i = 0;
var cls = '';
for (; i < len; i++) {
var arg = args[i];
if (arg == null) continue;
var toAdd = void 0;
switch (typeof arg) {
case 'boolean':
break;
case 'object':
{
if (Array.isArray(arg)) {
toAdd = classnames(arg);
} else {
toAdd = '';
for (var k in arg) {
if (arg[k] && k) {
toAdd && (toAdd += ' ');
toAdd += k;
}
}
}
break;
}
default:
{
toAdd = arg;
}
}
if (toAdd) {
cls && (cls += ' ');
cls += toAdd;
}
}
return cls;
};
function merge(registered, css, className) {
var registeredStyles = [];
var rawClassName = utils.getRegisteredStyles(registered, registeredStyles, className);
if (registeredStyles.length < 2) {
return className;
}
return rawClassName + css(registeredStyles);
}
var ClassNames =
/* #__PURE__ */
exports.withEmotionCache(function (props, cache) {
var rules = '';
var serializedHashes = '';
var hasRendered = false;
var css = function css() {
if (hasRendered && process.env.NODE_ENV !== 'production') {
throw new Error('css can only be used during render');
}
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
var serialized = serialize.serializeStyles(args, cache.registered);
if (isBrowser) {
utils.insertStyles(cache, serialized, false);
} else {
var res = utils.insertStyles(cache, serialized, false);
if (res !== undefined) {
rules += res;
}
}
if (!isBrowser) {
serializedHashes += " " + serialized.name;
}
return cache.key + "-" + serialized.name;
};
var cx = function cx() {
if (hasRendered && process.env.NODE_ENV !== 'production') {
throw new Error('cx can only be used during render');
}
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
args[_key2] = arguments[_key2];
}
return merge(cache.registered, css, classnames(args));
};
var content = {
css: css,
cx: cx,
theme: React.useContext(ThemeContext)
};
var ele = props.children(content);
hasRendered = true;
if (!isBrowser && rules.length !== 0) {
var _ref;
return React.createElement(React.Fragment, null, React.createElement("style", (_ref = {}, _ref["data-emotion-" + cache.key] = serializedHashes.substring(1), _ref.dangerouslySetInnerHTML = {
__html: rules
}, _ref.nonce = cache.sheet.nonce, _ref)), ele);
}
return ele;
});
exports.CacheProvider = CacheProvider;
exports.ClassNames = ClassNames;
exports.Global = Global;
exports.ThemeContext = ThemeContext;
exports.ThemeProvider = ThemeProvider;
exports.css = css;
exports.jsx = jsx;
exports.keyframes = keyframes;
exports.useTheme = useTheme;
exports.withTheme = withTheme;
throw new Error("The `@emotion/core` package has been renamed to `@emotion/react`. Please import it like this `import { jsx } from '@emotion/react'`.");

187

dist/core.cjs.prod.js
"use strict";
function _interopDefault(ex) {
return ex && "object" == typeof ex && "default" in ex ? ex.default : ex;
}
Object.defineProperty(exports, "__esModule", {
value: !0
});
var React = require("react"), createCache = _interopDefault(require("@emotion/cache")), _extends = _interopDefault(require("@babel/runtime/helpers/extends")), weakMemoize = _interopDefault(require("@emotion/weak-memoize")), hoistNonReactStatics = _interopDefault(require("hoist-non-react-statics")), utils = require("@emotion/utils"), serialize = require("@emotion/serialize"), sheet = require("@emotion/sheet"), isBrowser = "undefined" != typeof document, EmotionCacheContext = React.createContext("undefined" != typeof HTMLElement ? createCache() : null), CacheProvider = EmotionCacheContext.Provider;
exports.withEmotionCache = function(func) {
return React.forwardRef((function(props, ref) {
var cache = React.useContext(EmotionCacheContext);
return func(props, cache, ref);
}));
}, isBrowser || (exports.withEmotionCache = function(func) {
return function(props) {
var cache = React.useContext(EmotionCacheContext);
return null === cache ? (cache = createCache(), React.createElement(EmotionCacheContext.Provider, {
value: cache
}, func(props, cache))) : func(props, cache);
};
});
var ThemeContext = React.createContext({}), useTheme = function() {
return React.useContext(ThemeContext);
}, getTheme = function(outerTheme, theme) {
return "function" == typeof theme ? theme(outerTheme) : _extends({}, outerTheme, {}, theme);
}, createCacheWithTheme = weakMemoize((function(outerTheme) {
return weakMemoize((function(theme) {
return getTheme(outerTheme, theme);
}));
})), ThemeProvider = function(props) {
var theme = React.useContext(ThemeContext);
return props.theme !== theme && (theme = createCacheWithTheme(theme)(props.theme)),
React.createElement(ThemeContext.Provider, {
value: theme
}, props.children);
};
function withTheme(Component) {
var componentName = Component.displayName || Component.name || "Component", WithTheme = React.forwardRef((function(props, ref) {
var theme = React.useContext(ThemeContext);
return React.createElement(Component, _extends({
theme: theme,
ref: ref
}, props));
}));
return WithTheme.displayName = "WithTheme(" + componentName + ")", hoistNonReactStatics(WithTheme, Component);
}
var typePropName = "__EMOTION_TYPE_PLEASE_DO_NOT_USE__", hasOwnProperty = Object.prototype.hasOwnProperty, Emotion = exports.withEmotionCache((function(props, cache, ref) {
var cssProp = props.css;
"string" == typeof cssProp && void 0 !== cache.registered[cssProp] && (cssProp = cache.registered[cssProp]);
var type = props[typePropName], registeredStyles = [ cssProp ], className = "";
"string" == typeof props.className ? className = utils.getRegisteredStyles(cache.registered, registeredStyles, props.className) : null != props.className && (className = props.className + " ");
var serialized = serialize.serializeStyles(registeredStyles, void 0, "function" == typeof cssProp || Array.isArray(cssProp) ? React.useContext(ThemeContext) : void 0), rules = utils.insertStyles(cache, serialized, "string" == typeof type);
className += cache.key + "-" + serialized.name;
var newProps = {};
for (var key in props) hasOwnProperty.call(props, key) && "css" !== key && key !== typePropName && (newProps[key] = props[key]);
newProps.ref = ref, newProps.className = className;
var ele = React.createElement(type, newProps);
if (!isBrowser && void 0 !== rules) {
for (var _ref, serializedNames = serialized.name, next = serialized.next; void 0 !== next; ) serializedNames += " " + next.name,
next = next.next;
return React.createElement(React.Fragment, null, React.createElement("style", ((_ref = {})["data-emotion-" + cache.key] = serializedNames,
_ref.dangerouslySetInnerHTML = {
__html: rules
}, _ref.nonce = cache.sheet.nonce, _ref)), ele);
}
return ele;
})), jsx = function(type, props) {
var args = arguments;
if (null == props || !hasOwnProperty.call(props, "css")) return React.createElement.apply(void 0, args);
var argsLength = args.length, createElementArgArray = new Array(argsLength);
createElementArgArray[0] = Emotion;
var newProps = {};
for (var key in props) hasOwnProperty.call(props, key) && (newProps[key] = props[key]);
newProps[typePropName] = type, createElementArgArray[1] = newProps;
for (var i = 2; i < argsLength; i++) createElementArgArray[i] = args[i];
return React.createElement.apply(null, createElementArgArray);
}, Global = exports.withEmotionCache((function(props, cache) {
var styles = props.styles, serialized = serialize.serializeStyles([ styles ], void 0, "function" == typeof styles || Array.isArray(styles) ? React.useContext(ThemeContext) : void 0);
if (!isBrowser) {
for (var _ref, serializedNames = serialized.name, serializedStyles = serialized.styles, next = serialized.next; void 0 !== next; ) serializedNames += " " + next.name,
serializedStyles += next.styles, next = next.next;
var shouldCache = !0 === cache.compat, rules = cache.insert("", {
name: serializedNames,
styles: serializedStyles
}, cache.sheet, shouldCache);
return shouldCache ? null : React.createElement("style", ((_ref = {})["data-emotion-" + cache.key] = serializedNames,
_ref.dangerouslySetInnerHTML = {
__html: rules
}, _ref.nonce = cache.sheet.nonce, _ref));
}
var sheetRef = React.useRef();
return React.useLayoutEffect((function() {
var sheet$1 = new sheet.StyleSheet({
key: cache.key + "-global",
nonce: cache.sheet.nonce,
container: cache.sheet.container
}), node = document.querySelector("style[data-emotion-" + cache.key + '="' + serialized.name + '"]');
return null !== node && sheet$1.tags.push(node), cache.sheet.tags.length && (sheet$1.before = cache.sheet.tags[0]),
sheetRef.current = sheet$1, function() {
sheet$1.flush();
};
}), [ cache ]), React.useLayoutEffect((function() {
void 0 !== serialized.next && utils.insertStyles(cache, serialized.next, !0);
var sheet = sheetRef.current;
if (sheet.tags.length) {
var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;
sheet.before = element, sheet.flush();
}
cache.insert("", serialized, sheet, !1);
}), [ cache, serialized.name ]), null;
}));
function css() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
return serialize.serializeStyles(args);
}
var keyframes = function() {
var insertable = css.apply(void 0, arguments), name = "animation-" + insertable.name;
return {
name: name,
styles: "@keyframes " + name + "{" + insertable.styles + "}",
anim: 1,
toString: function() {
return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
}
};
}, classnames = function classnames(args) {
for (var len = args.length, i = 0, cls = ""; i < len; i++) {
var arg = args[i];
if (null != arg) {
var toAdd = void 0;
switch (typeof arg) {
case "boolean":
break;
case "object":
if (Array.isArray(arg)) toAdd = classnames(arg); else for (var k in toAdd = "",
arg) arg[k] && k && (toAdd && (toAdd += " "), toAdd += k);
break;
default:
toAdd = arg;
}
toAdd && (cls && (cls += " "), cls += toAdd);
}
}
return cls;
};
function merge(registered, css, className) {
var registeredStyles = [], rawClassName = utils.getRegisteredStyles(registered, registeredStyles, className);
return registeredStyles.length < 2 ? className : rawClassName + css(registeredStyles);
}
var ClassNames = exports.withEmotionCache((function(props, cache) {
var _ref, rules = "", serializedHashes = "", css = function() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
var serialized = serialize.serializeStyles(args, cache.registered);
if (isBrowser) utils.insertStyles(cache, serialized, !1); else {
var res = utils.insertStyles(cache, serialized, !1);
void 0 !== res && (rules += res);
}
return isBrowser || (serializedHashes += " " + serialized.name), cache.key + "-" + serialized.name;
}, content = {
css: css,
cx: function() {
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) args[_key2] = arguments[_key2];
return merge(cache.registered, css, classnames(args));
},
theme: React.useContext(ThemeContext)
}, ele = props.children(content);
return !0, isBrowser || 0 === rules.length ? ele : React.createElement(React.Fragment, null, React.createElement("style", ((_ref = {})["data-emotion-" + cache.key] = serializedHashes.substring(1),
_ref.dangerouslySetInnerHTML = {
__html: rules
}, _ref.nonce = cache.sheet.nonce, _ref)), ele);
}));
exports.CacheProvider = CacheProvider, exports.ClassNames = ClassNames, exports.Global = Global,
exports.ThemeContext = ThemeContext, exports.ThemeProvider = ThemeProvider, exports.css = css,
exports.jsx = jsx, exports.keyframes = keyframes, exports.useTheme = useTheme, exports.withTheme = withTheme;
throw new Error("The `@emotion/core` package has been renamed to `@emotion/react`. Please import it like this `import { jsx } from '@emotion/react'`.");

45

package.json
{
"name": "@emotion/core",
"version": "11.0.0-next.9",
"version": "11.0.0-next.10",
"main": "dist/core.cjs.js",
"module": "dist/core.esm.js",
"browser": {
"./dist/core.cjs.js": "./dist/core.browser.cjs.js",
"./dist/core.esm.js": "./dist/core.browser.esm.js"
},
"types": "types/index.d.ts",

@@ -22,42 +17,8 @@ "files": [

"scripts": {
"test:typescript": "dtslint types"
"test:typescript": "exit 0"
},
"dependencies": {
"@babel/runtime": "^7.7.2",
"@emotion/cache": "^11.0.0-next.6",
"@emotion/css": "^11.0.0-next.6",
"@emotion/serialize": "^0.12.0-next.3",
"@emotion/sheet": "0.10.0-next.0",
"@emotion/utils": "0.11.2",
"@emotion/weak-memoize": "0.2.4",
"hoist-non-react-statics": "^3.3.1"
},
"peerDependencies": {
"@babel/core": "^7.0.0",
"react": ">=16.8.0"
},
"peerDependenciesMeta": {
"@babel/core": {
"optional": true
}
},
"devDependencies": {
"@babel/core": "^7.7.2",
"@emotion/styled": "^11.0.0-next.9",
"@types/react": "^16.9.11",
"dtslint": "^0.3.0",
"emotion": "^11.0.0-next.8",
"emotion-server": "^11.0.0-next.8",
"html-tag-names": "^1.1.2",
"react": "^16.11.0",
"svg-tag-names": "^1.1.1"
},
"repository": "https://github.com/emotion-js/emotion/tree/master/packages/core",
"repository": "https://github.com/emotion-js/emotion/tree/master/removed-packages/core",
"publishConfig": {
"access": "public"
},
"umd:main": "dist/core.umd.min.js",
"preconstruct": {
"umdName": "emotionCore"
}
}

11

src/index.js

@@ -1,8 +0,3 @@

// @flow
export { withEmotionCache, CacheProvider } from './context'
export { jsx } from './jsx'
export { Global } from './global'
export { keyframes } from './keyframes'
export { ClassNames } from './class-names'
export { ThemeContext, useTheme, ThemeProvider, withTheme } from './theming'
export { default as css } from './css'
throw new Error(
"The `@emotion/core` package has been renamed to `@emotion/react`. Please import it like this `import { jsx } from '@emotion/react'`."
)
dist/core.browser.cjs.js
dist/core.browser.esm.js
dist/core.cjs.js.flow
dist/core.esm.js
dist/core.umd.min.js
dist/core.umd.min.js.map
macro.d.ts
macro.js
macro.js.flow
README.md
src/class-names.js
src/context.js
src/css.js
src/global.js
src/jsx.js
src/keyframes.js
src/theming.js
src/utils.js
types/helper.d.ts
types/index.d.ts
types/tests-css.tsx
types/tests-theming.tsx
types/tests.tsx
types/theming.d.ts
types/tsconfig.json
types/tslint.json
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc