@vinyasa/layout 1.0.19

package/dist/cjs/stack.cjs

@@ -0,0 +1,456 @@
+"use strict";
+var __webpack_modules__ = {
+    400 (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        function toPrimitive(t, r) {
+            if ("object" != typeof t || !t) return t;
+            var e = t[Symbol.toPrimitive];
+            if (void 0 !== e) {
+                var i = e.call(t, r || "default");
+                if ("object" != typeof i) return i;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+            }
+            return ("string" === r ? String : Number)(t);
+        }
+        function toPropertyKey(t) {
+            var i = toPrimitive(t, "string");
+            return "symbol" == typeof i ? i : String(i);
+        }
+        function _defineProperty(obj, key, value) {
+            key = toPropertyKey(key);
+            if (key in obj) Object.defineProperty(obj, key, {
+                value: value,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+            else obj[key] = value;
+            return obj;
+        }
+        function ownKeys(e, r) {
+            var t = Object.keys(e);
+            if (Object.getOwnPropertySymbols) {
+                var o = Object.getOwnPropertySymbols(e);
+                r && (o = o.filter(function(r) {
+                    return Object.getOwnPropertyDescriptor(e, r).enumerable;
+                })), t.push.apply(t, o);
+            }
+            return t;
+        }
+        function _objectSpread2(e) {
+            for(var r = 1; r < arguments.length; r++){
+                var t = null != arguments[r] ? arguments[r] : {};
+                r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
+                    _defineProperty(e, r, t[r]);
+                }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
+                    Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+                });
+            }
+            return e;
+        }
+        function mapValues(input, fn) {
+            var result = {};
+            for(var _key in input)result[_key] = fn(input[_key], _key);
+            return result;
+        }
+        var shouldApplyCompound = (compoundCheck, selections, defaultVariants)=>{
+            for (var key of Object.keys(compoundCheck)){
+                var _selections$key;
+                if (compoundCheck[key] !== (null != (_selections$key = selections[key]) ? _selections$key : defaultVariants[key])) return false;
+            }
+            return true;
+        };
+        var createRuntimeFn = (config)=>{
+            var runtimeFn = (options)=>{
+                var className = config.defaultClassName;
+                var selections = _objectSpread2(_objectSpread2({}, config.defaultVariants), options);
+                for(var variantName in selections){
+                    var _selections$variantNa;
+                    var variantSelection = null != (_selections$variantNa = selections[variantName]) ? _selections$variantNa : config.defaultVariants[variantName];
+                    if (null != variantSelection) {
+                        var selection = variantSelection;
+                        if ('boolean' == typeof selection) selection = true === selection ? 'true' : 'false';
+                        var selectionClassName = config.variantClassNames[variantName][selection];
+                        if (selectionClassName) className += ' ' + selectionClassName;
+                    }
+                }
+                for (var [compoundCheck, compoundClassName] of config.compoundVariants)if (shouldApplyCompound(compoundCheck, selections, config.defaultVariants)) className += ' ' + compoundClassName;
+                return className;
+            };
+            runtimeFn.variants = ()=>Object.keys(config.variantClassNames);
+            runtimeFn.classNames = {
+                get base () {
+                    return config.defaultClassName.split(' ')[0];
+                },
+                get variants () {
+                    return mapValues(config.variantClassNames, (classNames)=>mapValues(classNames, (className)=>className.split(' ')[0]));
+                }
+            };
+            return runtimeFn;
+        };
+        __webpack_require__.d(__webpack_exports__, {
+            c: ()=>createRuntimeFn
+        });
+    },
+    646 (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>flex_Flex
+        });
+        var jsx_runtime_ = __webpack_require__(732);
+        var external_react_ = __webpack_require__(15);
+        var spacing = __webpack_require__(153);
+        var createRuntimeFn_62c9670f_esm = __webpack_require__(400);
+        var flex = (0, createRuntimeFn_62c9670f_esm.c)({
+            defaultClassName: '_2mmdgz0',
+            variantClassNames: {
+                direction: {
+                    row: '_2mmdgz1',
+                    column: '_2mmdgz2'
+                },
+                align: {
+                    start: '_2mmdgz3',
+                    center: '_2mmdgz4',
+                    end: '_2mmdgz5',
+                    stretch: '_2mmdgz6'
+                },
+                justify: {
+                    start: '_2mmdgz7',
+                    center: '_2mmdgz8',
+                    end: '_2mmdgz9',
+                    between: '_2mmdgza',
+                    around: '_2mmdgzb'
+                },
+                wrap: {
+                    nowrap: '_2mmdgzc',
+                    wrap: '_2mmdgzd'
+                },
+                gap: {
+                    1: '_2mmdgze',
+                    2: '_2mmdgzf',
+                    3: '_2mmdgzg',
+                    4: '_2mmdgzh',
+                    5: '_2mmdgzi',
+                    6: '_2mmdgzj'
+                }
+            },
+            defaultVariants: {
+                direction: 'row',
+                wrap: 'nowrap'
+            },
+            compoundVariants: []
+        });
+        function _define_property(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;
+        }
+        function _object_spread(target) {
+            for(var i = 1; i < arguments.length; i++){
+                var source = null != arguments[i] ? arguments[i] : {};
+                var ownKeys = Object.keys(source);
+                if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                    return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+                }));
+                ownKeys.forEach(function(key) {
+                    _define_property(target, key, source[key]);
+                });
+            }
+            return target;
+        }
+        function Flex_ownKeys(object, enumerableOnly) {
+            var keys = Object.keys(object);
+            if (Object.getOwnPropertySymbols) {
+                var symbols = Object.getOwnPropertySymbols(object);
+                if (enumerableOnly) symbols = symbols.filter(function(sym) {
+                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+                });
+                keys.push.apply(keys, symbols);
+            }
+            return keys;
+        }
+        function _object_spread_props(target, source) {
+            source = null != source ? source : {};
+            if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+            else Flex_ownKeys(Object(source)).forEach(function(key) {
+                Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+            });
+            return target;
+        }
+        function _object_without_properties(source, excluded) {
+            if (null == source) return {};
+            var target = {}, sourceKeys, key, i;
+            if ("u" > typeof Reflect && Reflect.ownKeys) {
+                sourceKeys = Reflect.ownKeys(Object(source));
+                for(i = 0; i < sourceKeys.length; i++){
+                    key = sourceKeys[i];
+                    if (!(excluded.indexOf(key) >= 0)) {
+                        if (Object.prototype.propertyIsEnumerable.call(source, key)) target[key] = source[key];
+                    }
+                }
+                return target;
+            }
+            target = _object_without_properties_loose(source, excluded);
+            if (Object.getOwnPropertySymbols) {
+                sourceKeys = Object.getOwnPropertySymbols(source);
+                for(i = 0; i < sourceKeys.length; i++){
+                    key = sourceKeys[i];
+                    if (!(excluded.indexOf(key) >= 0)) {
+                        if (Object.prototype.propertyIsEnumerable.call(source, key)) target[key] = source[key];
+                    }
+                }
+            }
+            return target;
+        }
+        function _object_without_properties_loose(source, excluded) {
+            if (null == source) return {};
+            var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
+            for(i = 0; i < sourceKeys.length; i++){
+                key = sourceKeys[i];
+                if (!(excluded.indexOf(key) >= 0)) {
+                    if (Object.prototype.propertyIsEnumerable.call(source, key)) target[key] = source[key];
+                }
+            }
+            return target;
+        }
+        const Flex = /*#__PURE__*/ (0, external_react_.forwardRef)((_0, _1)=>{
+            let _ref = [
+                _0,
+                _1
+            ], [_ref1, ..._rest] = _ref, { as: Component = 'div', direction, align, justify, wrap, gap, m, mt, mr, mb, ml, mx, my, p, pt, pr, pb, pl, px, py, className, style, children } = _ref1, rest = _object_without_properties(_ref1, [
+                "as",
+                "direction",
+                "align",
+                "justify",
+                "wrap",
+                "gap",
+                "m",
+                "mt",
+                "mr",
+                "mb",
+                "ml",
+                "mx",
+                "my",
+                "p",
+                "pt",
+                "pr",
+                "pb",
+                "pl",
+                "px",
+                "py",
+                "className",
+                "style",
+                "children"
+            ]), [ref] = _rest;
+            const classes = className ? `${flex({
+                direction,
+                align,
+                justify,
+                wrap,
+                gap
+            })} ${className}` : flex({
+                direction,
+                align,
+                justify,
+                wrap,
+                gap
+            });
+            const spacingStyle = (0, spacing.v)({
+                m,
+                mt,
+                mr,
+                mb,
+                ml,
+                mx,
+                my,
+                p,
+                pt,
+                pr,
+                pb,
+                pl,
+                px,
+                py
+            });
+            return /*#__PURE__*/ (0, jsx_runtime_.jsx)(Component, _object_spread_props(_object_spread({
+                ref: ref,
+                className: classes,
+                style: _object_spread({}, spacingStyle, style)
+            }, rest), {
+                children: children
+            }));
+        });
+        Flex.displayName = 'Flex';
+        const flex_Flex = Flex;
+    },
+    153 (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            v: ()=>resolveSpacingStyle
+        });
+        const tokens_namespaceObject = require("@vinyasa/tokens");
+        const space = {
+            1: tokens_namespaceObject.themeContract.space1,
+            2: tokens_namespaceObject.themeContract.space2,
+            3: tokens_namespaceObject.themeContract.space3,
+            4: tokens_namespaceObject.themeContract.space4,
+            5: tokens_namespaceObject.themeContract.space5,
+            6: tokens_namespaceObject.themeContract.space6
+        };
+        const spacingPropertyMap = [
+            [
+                'm',
+                'margin'
+            ],
+            [
+                'mx',
+                'marginInline'
+            ],
+            [
+                'my',
+                'marginBlock'
+            ],
+            [
+                'mt',
+                'marginTop'
+            ],
+            [
+                'mr',
+                'marginRight'
+            ],
+            [
+                'mb',
+                'marginBottom'
+            ],
+            [
+                'ml',
+                'marginLeft'
+            ],
+            [
+                'p',
+                'padding'
+            ],
+            [
+                'px',
+                'paddingInline'
+            ],
+            [
+                'py',
+                'paddingBlock'
+            ],
+            [
+                'pt',
+                'paddingTop'
+            ],
+            [
+                'pr',
+                'paddingRight'
+            ],
+            [
+                'pb',
+                'paddingBottom'
+            ],
+            [
+                'pl',
+                'paddingLeft'
+            ]
+        ];
+        const resolveSpacingStyle = (props)=>{
+            const style = {};
+            for (const [propKey, cssProperty] of spacingPropertyMap){
+                const value = props[propKey];
+                if (void 0 !== value) style[cssProperty] = space[value];
+            }
+            return style;
+        };
+    },
+    15 (module) {
+        module.exports = require("react");
+    },
+    732 (module) {
+        module.exports = require("react/jsx-runtime");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        default: ()=>stack
+    });
+    var jsx_runtime_ = __webpack_require__(732);
+    var external_react_ = __webpack_require__(15);
+    var Flex = __webpack_require__(646);
+    function _define_property(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;
+    }
+    function _object_spread(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = null != arguments[i] ? arguments[i] : {};
+            var ownKeys = Object.keys(source);
+            if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+            ownKeys.forEach(function(key) {
+                _define_property(target, key, source[key]);
+            });
+        }
+        return target;
+    }
+    const Stack = /*#__PURE__*/ (0, external_react_.forwardRef)((props, ref)=>/*#__PURE__*/ (0, jsx_runtime_.jsx)(Flex.A, _object_spread({
+            ref: ref,
+            direction: "column"
+        }, props)));
+    Stack.displayName = 'Stack';
+    const stack_Stack = Stack;
+    const stack = stack_Stack;
+})();
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/stack.css

@@ -0,0 +1,80 @@
+._2mmdgz0 {
+  display: flex;
+}
+
+._2mmdgz1 {
+  flex-direction: row;
+}
+
+._2mmdgz2 {
+  flex-direction: column;
+}
+
+._2mmdgz3 {
+  align-items: flex-start;
+}
+
+._2mmdgz4 {
+  align-items: center;
+}
+
+._2mmdgz5 {
+  align-items: flex-end;
+}
+
+._2mmdgz6 {
+  align-items: stretch;
+}
+
+._2mmdgz7 {
+  justify-content: flex-start;
+}
+
+._2mmdgz8 {
+  justify-content: center;
+}
+
+._2mmdgz9 {
+  justify-content: flex-end;
+}
+
+._2mmdgza {
+  justify-content: space-between;
+}
+
+._2mmdgzb {
+  justify-content: space-around;
+}
+
+._2mmdgzc {
+  flex-wrap: nowrap;
+}
+
+._2mmdgzd {
+  flex-wrap: wrap;
+}
+
+._2mmdgze {
+  gap: var(--vinyasa-space1);
+}
+
+._2mmdgzf {
+  gap: var(--vinyasa-space2);
+}
+
+._2mmdgzg {
+  gap: var(--vinyasa-space3);
+}
+
+._2mmdgzh {
+  gap: var(--vinyasa-space4);
+}
+
+._2mmdgzi {
+  gap: var(--vinyasa-space5);
+}
+
+._2mmdgzj {
+  gap: var(--vinyasa-space6);
+}
+