musae 0.1.20 → 0.1.21

package/dist/node_modules/@stylexjs/stylex/lib/stylex.js

@@ -0,0 +1,150 @@
+import { slicedToArray as _slicedToArray } from '../../../../_virtual/_rollupPluginBabelHelpers.js';
+import { __exports as stylex } from '../../../../_virtual/stylex.js';
+import { __exports as styleq } from '../../../../_virtual/styleq.js';
+import '../../../styleq/dist/styleq.js';
+
+Object.defineProperty(stylex, "__esModule", {
+  value: true
+});
+stylex.__monkey_patch__ = __monkey_patch__;
+stylex.keyframes = stylex.include = stylex.firstThatWorks = stylex.defineVars = stylex["default"] = stylex.createTheme = stylex.create = void 0;
+var props_1 = stylex.props = props;
+stylex.types = stylex.stylex = void 0;
+var _styleq = styleq;
+function props() {
+  var options = this;
+  for (var _len = arguments.length, styles = new Array(_len), _key = 0; _key < _len; _key++) {
+    styles[_key] = arguments[_key];
+  }
+  if (__implementations.props) {
+    return __implementations.props.call(options, styles);
+  }
+  var _ref = (0, _styleq.styleq)(styles),
+    _ref2 = _slicedToArray(_ref, 2),
+    className = _ref2[0],
+    style = _ref2[1];
+  var result = {};
+  if (className != null && className !== '') {
+    result.className = className;
+  }
+  if (style != null && Object.keys(style).length > 0) {
+    result.style = style;
+  }
+  return result;
+}
+function stylexCreate(styles) {
+  if (__implementations.create != null) {
+    var _create = __implementations.create;
+    return _create(styles);
+  }
+  throw new Error('stylex.create should never be called. It should be compiled away.');
+}
+function stylexDefineVars(styles) {
+  if (__implementations.defineVars) {
+    return __implementations.defineVars(styles);
+  }
+  throw new Error('stylex.defineVars should never be called. It should be compiled away.');
+}
+var stylexCreateTheme = function stylexCreateTheme(baseTokens, overrides) {
+  if (__implementations.createTheme) {
+    return __implementations.createTheme(baseTokens, overrides);
+  }
+  throw new Error('stylex.createTheme should never be called. It should be compiled away.');
+};
+var stylexInclude = function stylexInclude(styles) {
+  if (__implementations.include) {
+    return __implementations.include(styles);
+  }
+  throw new Error('stylex.extends should never be called. It should be compiled away.');
+};
+var create = stylex.create = stylexCreate;
+var defineVars = stylex.defineVars = stylexDefineVars;
+var createTheme = stylex.createTheme = stylexCreateTheme;
+var include = stylex.include = stylexInclude;
+var types = stylex.types = {
+  angle: function angle(_v) {
+    throw new Error(errorForType('angle'));
+  },
+  color: function color(_v) {
+    throw new Error(errorForType('color'));
+  },
+  url: function url(_v) {
+    throw new Error(errorForType('url'));
+  },
+  image: function image(_v) {
+    throw new Error(errorForType('image'));
+  },
+  integer: function integer(_v) {
+    throw new Error(errorForType('integer'));
+  },
+  lengthPercentage: function lengthPercentage(_v) {
+    throw new Error(errorForType('lengthPercentage'));
+  },
+  length: function length(_v) {
+    throw new Error(errorForType('length'));
+  },
+  percentage: function percentage(_v) {
+    throw new Error(errorForType('percentage'));
+  },
+  number: function number(_v) {
+    throw new Error(errorForType('number'));
+  },
+  resolution: function resolution(_v) {
+    throw new Error(errorForType('resolution'));
+  },
+  time: function time(_v) {
+    throw new Error(errorForType('time'));
+  },
+  transformFunction: function transformFunction(_v) {
+    throw new Error(errorForType('transformFunction'));
+  },
+  transformList: function transformList(_v) {
+    throw new Error(errorForType('transformList'));
+  }
+};
+var errorForType = function errorForType(type) {
+  return "stylex.types.".concat(type, " should be compiled away by @stylexjs/babel-plugin");
+};
+var keyframes = function keyframes(_keyframes) {
+  if (__implementations.keyframes) {
+    return __implementations.keyframes(_keyframes);
+  }
+  throw new Error('stylex.keyframes should never be called');
+};
+stylex.keyframes = keyframes;
+var firstThatWorks = function firstThatWorks() {
+  if (__implementations.firstThatWorks) {
+    return __implementations.firstThatWorks.apply(__implementations, arguments);
+  }
+  throw new Error('stylex.firstThatWorks should never be called.');
+};
+stylex.firstThatWorks = firstThatWorks;
+function _stylex() {
+  for (var _len2 = arguments.length, styles = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    styles[_key2] = arguments[_key2];
+  }
+  var _ref3 = (0, _styleq.styleq)(styles),
+    _ref4 = _slicedToArray(_ref3, 1),
+    className = _ref4[0];
+  return className;
+}
+_stylex.props = props;
+_stylex.create = create;
+_stylex.defineVars = defineVars;
+_stylex.createTheme = createTheme;
+_stylex.include = include;
+_stylex.keyframes = keyframes;
+_stylex.firstThatWorks = firstThatWorks;
+_stylex.types = types;
+var __implementations = {};
+function __monkey_patch__(key, implementation) {
+  if (key === 'types') {
+    Object.assign(types, implementation);
+  } else {
+    __implementations[key] = implementation;
+  }
+}
+stylex.stylex = _stylex;
+stylex["default"] = _stylex;
+
+export { props_1 as props };

package/dist/node_modules/styleq/dist/styleq.js

@@ -0,0 +1,149 @@
+import { __exports as styleq$1 } from '../../../_virtual/styleq.js';
+
+/**
+ * Copyright (c) Nicolas Gallagher
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+Object.defineProperty(styleq$1, "__esModule", {
+  value: true
+});
+styleq$1.styleq = void 0;
+var cache = new WeakMap();
+var compiledKey = '$$css';
+function createStyleq(options) {
+  var disableCache;
+  var disableMix;
+  var transform;
+  if (options != null) {
+    disableCache = options.disableCache === true;
+    disableMix = options.disableMix === true;
+    transform = options.transform;
+  }
+  return function styleq() {
+    // Keep track of property commits to the className
+    var definedProperties = []; // The className and inline style to build up
+
+    var className = '';
+    var inlineStyle = null; // The current position in the cache graph
+
+    var nextCache = disableCache ? null : cache; // This way of creating an array from arguments is fastest
+
+    var styles = new Array(arguments.length);
+    for (var i = 0; i < arguments.length; i++) {
+      styles[i] = arguments[i];
+    } // Iterate over styles from last to first
+
+    while (styles.length > 0) {
+      var possibleStyle = styles.pop(); // Skip empty items
+
+      if (possibleStyle == null || possibleStyle === false) {
+        continue;
+      } // Push nested styles back onto the stack to be processed
+
+      if (Array.isArray(possibleStyle)) {
+        for (var _i = 0; _i < possibleStyle.length; _i++) {
+          styles.push(possibleStyle[_i]);
+        }
+        continue;
+      } // Process an individual style object
+
+      var style = transform != null ? transform(possibleStyle) : possibleStyle;
+      if (style.$$css) {
+        // Build up the class names defined by this object
+        var classNameChunk = ''; // Check the cache to see if we've already done this work
+
+        if (nextCache != null && nextCache.has(style)) {
+          // Cache: read
+          var cacheEntry = nextCache.get(style);
+          if (cacheEntry != null) {
+            classNameChunk = cacheEntry[0]; // $FlowIgnore
+
+            definedProperties.push.apply(definedProperties, cacheEntry[1]);
+            nextCache = cacheEntry[2];
+          }
+        } // Update the chunks with data from this object
+        else {
+          // The properties defined by this object
+          var definedPropertiesChunk = [];
+          for (var prop in style) {
+            var value = style[prop];
+            if (prop === compiledKey) continue; // Each property value is used as an HTML class name
+            // { 'debug.string': 'debug.string', opacity: 's-jskmnoqp' }
+
+            if (typeof value === 'string' || value === null) {
+              // Only add to chunks if this property hasn't already been seen
+              if (!definedProperties.includes(prop)) {
+                definedProperties.push(prop);
+                if (nextCache != null) {
+                  definedPropertiesChunk.push(prop);
+                }
+                if (typeof value === 'string') {
+                  classNameChunk += classNameChunk ? ' ' + value : value;
+                }
+              }
+            } // If we encounter a value that isn't a string or `null`
+            else {
+              console.error("styleq: ".concat(prop, " typeof ").concat(String(value), " is not \"string\" or \"null\"."));
+            }
+          } // Cache: write
+
+          if (nextCache != null) {
+            // Create the next WeakMap for this sequence of styles
+            var weakMap = new WeakMap();
+            nextCache.set(style, [classNameChunk, definedPropertiesChunk, weakMap]);
+            nextCache = weakMap;
+          }
+        } // Order of classes in chunks matches property-iteration order of style
+        // object. Order of chunks matches passed order of styles from first to
+        // last (which we iterate over in reverse).
+
+        if (classNameChunk) {
+          className = className ? classNameChunk + ' ' + className : classNameChunk;
+        }
+      } // ----- DYNAMIC: Process inline style object -----
+      else {
+        if (disableMix) {
+          if (inlineStyle == null) {
+            inlineStyle = {};
+          }
+          inlineStyle = Object.assign({}, style, inlineStyle);
+        } else {
+          var subStyle = null;
+          for (var _prop in style) {
+            var _value = style[_prop];
+            if (_value !== undefined) {
+              if (!definedProperties.includes(_prop)) {
+                if (_value != null) {
+                  if (inlineStyle == null) {
+                    inlineStyle = {};
+                  }
+                  if (subStyle == null) {
+                    subStyle = {};
+                  }
+                  subStyle[_prop] = _value;
+                }
+                definedProperties.push(_prop); // Cache is unnecessary overhead if results can't be reused.
+
+                nextCache = null;
+              }
+            }
+          }
+          if (subStyle != null) {
+            inlineStyle = Object.assign(subStyle, inlineStyle);
+          }
+        }
+      }
+    }
+    var styleProps = [className, inlineStyle];
+    return styleProps;
+  };
+}
+var styleq = createStyleq();
+styleq$1.styleq = styleq;
+styleq.factory = createStyleq;
+
+export { styleq$1 as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musae",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "musae-ui",
   "author": "tutu@fantufantu.com",
   "license": "MIT",