@modern-js/plugin-tailwindcss 1.4.0 → 1.5.0

package/dist/js/node/design-token/runtime/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+
+var _plugin = _interopRequireWildcard(require("./plugin"));
+
+Object.keys(_plugin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _plugin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _plugin[key];
+    }
+  });
+});
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var _default = _plugin.default;
+exports.default = _default;

package/dist/js/node/design-token/runtime/plugin.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDesignTokens = exports.default = exports.DesignTokenContext = void 0;
+
+var _hoistNonReactStatics = _interopRequireDefault(require("hoist-non-react-statics"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const DesignTokenContext = /*#__PURE__*/_react.default.createContext({});
+
+exports.DesignTokenContext = DesignTokenContext;
+
+const useDesignTokens = () => (0, _react.useContext)(DesignTokenContext);
+
+exports.useDesignTokens = useDesignTokens;
+
+var _default = (options = {}) => ({
+  name: '@modern-js/plugin-design-token',
+  setup: () => ({
+    hoc({
+      App
+    }, next) {
+      const DesignTokenAppWrapper = props => {
+        const {
+          token = {},
+          useStyledComponentsThemeProvider = false,
+          useDesignTokenContext = false
+        } = options;
+
+        if (useStyledComponentsThemeProvider && useDesignTokenContext) {
+          const {
+            ThemeProvider
+          } = require('@modern-js/runtime/styled');
+
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(ThemeProvider, {
+            theme: token,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(DesignTokenContext.Provider, {
+              value: token,
+              children: /*#__PURE__*/(0, _jsxRuntime.jsx)(App, _objectSpread({}, props))
+            })
+          });
+        } else if (useStyledComponentsThemeProvider) {
+          const {
+            ThemeProvider
+          } = require('@modern-js/runtime/styled');
+
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(ThemeProvider, {
+            theme: token,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(App, _objectSpread({}, props))
+          });
+        } else if (useDesignTokenContext) {
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(DesignTokenContext.Provider, {
+            value: token,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(App, _objectSpread({}, props))
+          });
+        } else {
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(App, _objectSpread({}, props));
+        }
+      };
+
+      return next({
+        App: (0, _hoistNonReactStatics.default)(DesignTokenAppWrapper, App)
+      });
+    }
+
+  })
+});
+
+exports.default = _default;

package/dist/js/treeshaking/cli.js

@@ -0,0 +1,135 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import path from 'path';
+import { PLUGIN_SCHEMAS, fs, CONFIG_CACHE_DIR, globby, nanoid, slash } from '@modern-js/utils';
+import DesignTokenPlugin from "./design-token/cli";
+import { getTailwindConfig } from "./tailwind";
+import { template, checkTwinMacroNotExist } from "./utils";
+var supportCssInJsLibrary = 'styled-components';
+export var getRandomTwConfigFileName = function getRandomTwConfigFileName(internalDirectory) {
+  return slash(path.join(internalDirectory, "tailwind.config.".concat(Date.now(), ".").concat(nanoid(), ".js")));
+};
+export default (function () {
+  return {
+    name: '@modern-js/plugin-tailwindcss',
+    // support designSystem.supportStyledComponents
+    usePlugins: [DesignTokenPlugin()],
+    setup: function () {
+      var _setup = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(api) {
+        var _api$useAppContext, appDirectory, internalDirectory, internalTwConfigPath, notHaveTwinMacro;
+
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _api$useAppContext = api.useAppContext(), appDirectory = _api$useAppContext.appDirectory, internalDirectory = _api$useAppContext.internalDirectory;
+                internalTwConfigPath = ''; // When reinstalling dependencies, most of the time the project will be restarted
+
+                _context.next = 4;
+                return checkTwinMacroNotExist(appDirectory);
+
+              case 4:
+                notHaveTwinMacro = _context.sent;
+                return _context.abrupt("return", {
+                  prepare: function prepare() {
+                    if (notHaveTwinMacro) {
+                      return;
+                    }
+
+                    internalTwConfigPath = getRandomTwConfigFileName(internalDirectory);
+                    var globPattern = slash(path.join(appDirectory, CONFIG_CACHE_DIR, '*.cjs'));
+                    var files = globby.sync(globPattern, {
+                      absolute: true
+                    });
+
+                    if (files.length > 0) {
+                      fs.writeFileSync(internalTwConfigPath, template(files[files.length - 1]), 'utf-8');
+                    }
+                  },
+                  validateSchema: function validateSchema() {
+                    return PLUGIN_SCHEMAS['@modern-js/plugin-tailwindcss'];
+                  },
+                  config: function config() {
+                    return {
+                      tools: {
+                        // TODO: Add interface about postcss config
+                        // TODO: In module project, also is called, but should not be called.
+                        postcss: function postcss(config) {
+                          var modernConfig = api.useResolvedConfigContext();
+                          var tailwindConfig = getTailwindConfig(modernConfig, {
+                            pureConfig: {
+                              content: ['./config/html/**/*.html', './config/html/**/*.ejs', './config/html/**/*.hbs', './src/**/*.js', './src/**/*.jsx', './src/**/*.ts', './src/**/*.tsx', // about storybook
+                              './storybook/**/*', './styles/**/*.less', './styles/**/*.css', './styles/**/*.sass', './styles/**/*.scss']
+                            }
+                          });
+
+                          if (Array.isArray(config.postcssOptions.plugins)) {
+                            config.postcssOptions.plugins.push(require('tailwindcss')(tailwindConfig));
+                          } else {
+                            config.postcssOptions.plugins = [require('tailwindcss')(tailwindConfig)];
+                          }
+                        },
+                        babel: function babel(config) {
+                          var _config$plugins;
+
+                          if (notHaveTwinMacro) {
+                            return;
+                          }
+
+                          var twinConfig = {
+                            twin: {
+                              preset: supportCssInJsLibrary,
+                              config: internalTwConfigPath
+                            }
+                          };
+                          (_config$plugins = config.plugins) === null || _config$plugins === void 0 ? void 0 : _config$plugins.some(function (plugin) {
+                            if (Array.isArray(plugin) && plugin[0]) {
+                              var pluginTarget = plugin[0];
+                              var pluginOptions = plugin[1];
+
+                              if (typeof pluginTarget === 'string' && // TODO: use babel chain
+                              slash(pluginTarget).includes('compiled/babel-plugin-macros')) {
+                                if (pluginOptions) {
+                                  pluginOptions = _objectSpread(_objectSpread({}, pluginOptions), twinConfig);
+                                } else {
+                                  plugin.push(twinConfig);
+                                }
+
+                                return true;
+                              }
+                            }
+
+                            return false;
+                          });
+                        }
+                      }
+                    };
+                  },
+                  moduleTailwindConfig: function moduleTailwindConfig() {
+                    var modernConfig = api.useResolvedConfigContext();
+                    var tailwindConfig = getTailwindConfig(modernConfig, {
+                      pureConfig: {
+                        content: ['./src/**/*.js', './src/**/*.jsx', './src/**/*.ts', './src/**/*.tsx', './src/**/*.less', './src/**/*.css', './src/**/*.sass', './src/**/*.scss', './styles/**/*.less', './styles/**/*.css', './styles/**/*.sass', './styles/**/*.scss']
+                      }
+                    });
+                    return require('tailwindcss')(tailwindConfig);
+                  }
+                });
+
+              case 6:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function setup(_x) {
+        return _setup.apply(this, arguments);
+      }
+
+      return setup;
+    }()
+  };
+});

package/dist/js/treeshaking/design-token/cli/index.js

@@ -0,0 +1,106 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { lazyImport, PLUGIN_SCHEMAS, createRuntimeExportsUtils } from '@modern-js/utils';
+export default (function () {
+  return {
+    name: '@modern-js/plugin-design-token',
+    setup: function setup(api) {
+      var pluginsExportsUtils;
+      var resolveConfig = lazyImport('tailwindcss/resolveConfig', require);
+      var PLUGIN_IDENTIFIER = 'designToken';
+
+      var getDesignTokens = function getDesignTokens(userConfig) {
+        var _ref = userConfig,
+            designSystem = _ref.source.designSystem; // TODO: Type to be filled
+
+        var tailwindcssConfig = {};
+        tailwindcssConfig.theme = designSystem ? _objectSpread({}, designSystem) : {}; // not use default design token when designToken.defaultTheme is false or theme is false
+
+        if (!designSystem) {
+          tailwindcssConfig.presets = [];
+        } // when only designSystem exist, need remove supportStyledComponents
+
+
+        if (designSystem) {
+          delete tailwindcssConfig.theme.supportStyledComponents;
+        }
+
+        return resolveConfig(tailwindcssConfig).theme || {};
+      };
+
+      return {
+        config: function config() {
+          var appContext = api.useAppContext();
+          pluginsExportsUtils = createRuntimeExportsUtils(appContext.internalDirectory, 'plugins');
+          return {
+            source: {
+              alias: {
+                '@modern-js/runtime/plugins': pluginsExportsUtils.getPath()
+              }
+            },
+            tools: {// TODO: support less、scss、css vars
+              // less: https://github.com/modern-js-dev/modern.js/pull/398/files#diff-f77c749e403fbf1fb676d5687bef3d7138a230331c849298d8afaff9b6afbc3dR166
+              // sass: https://github.com/modern-js-dev/modern.js/pull/398/files#diff-f77c749e403fbf1fb676d5687bef3d7138a230331c849298d8afaff9b6afbc3dR229
+              // postcss: https://github.com/modern-js-dev/modern.js/pull/398/files#diff-f77c749e403fbf1fb676d5687bef3d7138a230331c849298d8afaff9b6afbc3dR281
+            }
+          };
+        },
+        modifyEntryImports: function modifyEntryImports(_ref2) {
+          var entrypoint = _ref2.entrypoint,
+              imports = _ref2.imports;
+          var userConfig = api.useResolvedConfigContext();
+          var designSystem = userConfig.source.designSystem;
+
+          if (_typeof(designSystem) === 'object' && designSystem.supportStyledComponents) {
+            var designTokens = getDesignTokens(userConfig);
+            imports.push({
+              value: '@modern-js/runtime/plugins',
+              specifiers: [{
+                imported: PLUGIN_IDENTIFIER
+              }],
+              initialize: "\n  const designTokens = ".concat(JSON.stringify(designTokens), ";\n            ")
+            });
+          }
+
+          return {
+            entrypoint: entrypoint,
+            imports: imports
+          };
+        },
+        modifyEntryRuntimePlugins: function modifyEntryRuntimePlugins(_ref3) {
+          var entrypoint = _ref3.entrypoint,
+              plugins = _ref3.plugins;
+
+          var _ref4 = api.useResolvedConfigContext(),
+              designSystem = _ref4.source.designSystem;
+
+          var useSCThemeProvider = true;
+
+          if (designSystem) {
+            // when designSystem exist, designToken.styledComponents`s default value is false.
+            useSCThemeProvider = (designSystem === null || designSystem === void 0 ? void 0 : designSystem.supportStyledComponents) || false;
+          }
+
+          if (_typeof(designSystem) === 'object' && designSystem.supportStyledComponents) {
+            plugins.push({
+              name: PLUGIN_IDENTIFIER,
+              options: "{token: designTokens, useStyledComponentsThemeProvider: ".concat(useSCThemeProvider ? 'true' : 'false', ", useDesignTokenContext: false}")
+            });
+          }
+
+          return {
+            entrypoint: entrypoint,
+            plugins: plugins
+          };
+        },
+        validateSchema: function validateSchema() {
+          // add source.designSystem.supportStyledComponents config
+          return PLUGIN_SCHEMAS['@modern-js/plugin-design-token'];
+        },
+        addRuntimeExports: function addRuntimeExports() {
+          pluginsExportsUtils.addExport("export { default as designToken } from '@modern-js/plugin-tailwindcss/runtime-design-token'");
+        }
+      };
+    }
+  };
+});

package/dist/js/treeshaking/design-token/index.js

@@ -0,0 +1,2 @@
+export { default } from "./runtime";
+export * from "./runtime";

package/dist/js/treeshaking/design-token/postcss-plugin/index.js

@@ -0,0 +1,30 @@
+export default (function () {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref$cssVarsHash = _ref.cssVarsHash,
+      cssVarsHash = _ref$cssVarsHash === void 0 ? {} : _ref$cssVarsHash;
+
+  return {
+    postcssPlugin: 'postcss-replace-css-vars',
+    Declaration: function (_Declaration) {
+      function Declaration(_x) {
+        return _Declaration.apply(this, arguments);
+      }
+
+      Declaration.toString = function () {
+        return _Declaration.toString();
+      };
+
+      return Declaration;
+    }(function (decl) {
+      if (decl.value && typeof decl.value === 'string') {
+        decl.value = decl.value.replace(/--\S*/g, function (match) {
+          if (cssVarsHash[match]) {
+            return cssVarsHash[match];
+          }
+
+          return match;
+        });
+      }
+    })
+  };
+});

package/dist/js/treeshaking/design-token/runtime/index.js

@@ -0,0 +1,3 @@
+import designTokenPlugin from "./plugin";
+export * from "./plugin";
+export default designTokenPlugin;

package/dist/js/treeshaking/design-token/runtime/plugin.js

@@ -0,0 +1,62 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import hoistNonReactStatics from 'hoist-non-react-statics';
+import React, { useContext } from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+export var DesignTokenContext = /*#__PURE__*/React.createContext({});
+export var useDesignTokens = function useDesignTokens() {
+  return useContext(DesignTokenContext);
+};
+export default (function () {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return {
+    name: '@modern-js/plugin-design-token',
+    setup: function setup() {
+      return {
+        hoc: function hoc(_ref, next) {
+          var App = _ref.App;
+
+          var DesignTokenAppWrapper = function DesignTokenAppWrapper(props) {
+            var _options$token = options.token,
+                token = _options$token === void 0 ? {} : _options$token,
+                _options$useStyledCom = options.useStyledComponentsThemeProvider,
+                useStyledComponentsThemeProvider = _options$useStyledCom === void 0 ? false : _options$useStyledCom,
+                _options$useDesignTok = options.useDesignTokenContext,
+                useDesignTokenContext = _options$useDesignTok === void 0 ? false : _options$useDesignTok;
+
+            if (useStyledComponentsThemeProvider && useDesignTokenContext) {
+              var _require = require('@modern-js/runtime/styled'),
+                  ThemeProvider = _require.ThemeProvider;
+
+              return /*#__PURE__*/_jsx(ThemeProvider, {
+                theme: token,
+                children: /*#__PURE__*/_jsx(DesignTokenContext.Provider, {
+                  value: token,
+                  children: /*#__PURE__*/_jsx(App, _objectSpread({}, props))
+                })
+              });
+            } else if (useStyledComponentsThemeProvider) {
+              var _require2 = require('@modern-js/runtime/styled'),
+                  _ThemeProvider = _require2.ThemeProvider;
+
+              return /*#__PURE__*/_jsx(_ThemeProvider, {
+                theme: token,
+                children: /*#__PURE__*/_jsx(App, _objectSpread({}, props))
+              });
+            } else if (useDesignTokenContext) {
+              return /*#__PURE__*/_jsx(DesignTokenContext.Provider, {
+                value: token,
+                children: /*#__PURE__*/_jsx(App, _objectSpread({}, props))
+              });
+            } else {
+              return /*#__PURE__*/_jsx(App, _objectSpread({}, props));
+            }
+          };
+
+          return next({
+            App: hoistNonReactStatics(DesignTokenAppWrapper, App)
+          });
+        }
+      };
+    }
+  };
+});

package/dist/js/treeshaking/index.js

@@ -0,0 +1 @@
+export { default } from "./cli";

package/dist/js/treeshaking/tailwind.js

@@ -0,0 +1,51 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { applyOptionsChain, logger } from '@modern-js/utils';
+import { merge, cloneDeep } from '@modern-js/utils/lodash';
+
+var checkIfExistNotAllowKeys = function checkIfExistNotAllowKeys(tailwindConfig) {
+  var notAllowExistKeys = ['theme'];
+  var notAllowKey = '';
+  var ret = Object.keys(tailwindConfig).some(function (key) {
+    return notAllowExistKeys.includes(key) && (notAllowKey = key);
+  });
+  return [ret, notAllowKey];
+};
+
+var getPureDesignSystemConfig = function getPureDesignSystemConfig(designSystemConfig) {
+  var pureDesignSystemConfig = cloneDeep(designSystemConfig);
+  delete pureDesignSystemConfig.supportStyledComponents;
+  return pureDesignSystemConfig;
+};
+
+var getTailwindConfig = function getTailwindConfig(config) {
+  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var purgeConfig = merge({
+    // TODO: how the operating environment is determined
+    enabled: process.env.NODE_ENV === 'production',
+    // TODO: Remove or not
+    layers: ['utilities'],
+    content: []
+  }, option.pureConfig || {});
+  var defaultTailwindConfig = {
+    purge: purgeConfig
+  };
+  var tailwindConfig = applyOptionsChain(defaultTailwindConfig, config.tools.tailwindcss || {});
+  var designSystem = getPureDesignSystemConfig(config.source.designSystem || {});
+
+  var _checkIfExistNotAllow = checkIfExistNotAllowKeys(tailwindConfig),
+      _checkIfExistNotAllow2 = _slicedToArray(_checkIfExistNotAllow, 2),
+      exist = _checkIfExistNotAllow2[0],
+      key = _checkIfExistNotAllow2[1];
+
+  if (exist) {
+    logger.error("should not exist '".concat(key, "' on tools.tailwindcss, please remove it")); // eslint-disable-next-line no-process-exit
+
+    process.exit(0);
+  } // Because there is no default theme configuration
+
+
+  tailwindConfig.theme = designSystem || {};
+  return tailwindConfig;
+};
+
+export { getTailwindConfig };

package/dist/js/treeshaking/utils.js

@@ -0,0 +1,56 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import path from 'path';
+import { fs } from '@modern-js/utils';
+export var template = function template(configPath) {
+  return "\nfunction _interopRequireDefault(obj) {\n    return obj && obj.__esModule ? obj : { default: obj };\n}\nconst modernConfig = _interopRequireDefault(require('".concat(configPath, "')).default;\n\nconst theme =\n    modernConfig && modernConfig.source && modernConfig.source.designSystem\n      ? modernConfig.source.designSystem\n      : {};\nconst tailwindcss =\n    modernConfig && modernConfig.tools && modernConfig.tools.tailwindcss\n      ? modernConfig.tools.tailwindcss\n      : {};\n\nmodule.exports = {\n    theme,\n    ...tailwindcss,\n};\n");
+};
+export var checkTwinMacroNotExist = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(appDirectory) {
+    var depName, packageJson;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            depName = 'twin.macro';
+            _context.next = 3;
+            return fs.readJSON(path.join(appDirectory, 'package.json'), {
+              "throws": false
+            });
+
+          case 3:
+            _context.t0 = _context.sent;
+
+            if (_context.t0) {
+              _context.next = 6;
+              break;
+            }
+
+            _context.t0 = {};
+
+          case 6:
+            packageJson = _context.t0;
+
+            if (!(_typeof(packageJson.dependencies) === 'object' && packageJson.dependencies[depName] || _typeof(packageJson.devDependencies) === 'object' && packageJson.devDependencies[depName])) {
+              _context.next = 9;
+              break;
+            }
+
+            return _context.abrupt("return", false);
+
+          case 9:
+            return _context.abrupt("return", true);
+
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function checkTwinMacroNotExist(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/types/design-token/cli/index.d.ts

@@ -0,0 +1,5 @@
+import type { CliPlugin } from '@modern-js/core';
+
+declare const _default: () => CliPlugin;
+
+export default _default;

package/dist/types/design-token/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './runtime';
+export * from './runtime';

package/dist/types/design-token/postcss-plugin/index.d.ts

@@ -0,0 +1,12 @@
+import type { Declaration } from 'postcss';
+
+declare const _default: ({
+  cssVarsHash
+}?: {
+  cssVarsHash?: Record<string, string> | undefined;
+}) => {
+  postcssPlugin: string;
+  Declaration(decl: Declaration): void;
+};
+
+export default _default;

package/dist/types/design-token/runtime/index.d.ts

@@ -0,0 +1,3 @@
+import designTokenPlugin from './plugin';
+export * from './plugin';
+export default designTokenPlugin;

package/dist/types/design-token/runtime/plugin.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from '@modern-js/runtime';
+import React from 'react';
+export declare const DesignTokenContext: React.Context<any>;
+export declare const useDesignTokens: () => IDesignTokens;
+
+declare const _default: (options?: {
+  token?: Record<string, any>;
+  useStyledComponentsThemeProvider?: boolean;
+  useDesignTokenContext?: boolean;
+}) => Plugin;
+
+export default _default;