@vinyasa/layout 1.0.19

package/dist/cjs/surface.cjs

@@ -0,0 +1,390 @@
+"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
+        });
+    },
+    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: ()=>components_surface
+    });
+    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 surface = (0, createRuntimeFn_62c9670f_esm.c)({
+        defaultClassName: '_1b2xjv10',
+        variantClassNames: {
+            radius: {
+                sm: '_1b2xjv11',
+                md: '_1b2xjv12',
+                full: '_1b2xjv13'
+            },
+            elevation: {
+                raised: '_1b2xjv14',
+                overlay: '_1b2xjv15',
+                modal: '_1b2xjv16'
+            }
+        },
+        defaultVariants: {
+            radius: 'md'
+        },
+        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 Surface_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 Surface_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 Surface = /*#__PURE__*/ (0, external_react_.forwardRef)((_0, _1)=>{
+        let _ref = [
+            _0,
+            _1
+        ], [_ref1, ..._rest] = _ref, { as: Component = 'div', radius, elevation, m, mt, mr, mb, ml, mx, my, p, pt, pr, pb, pl, px, py, className, style, children } = _ref1, rest = _object_without_properties(_ref1, [
+            "as",
+            "radius",
+            "elevation",
+            "m",
+            "mt",
+            "mr",
+            "mb",
+            "ml",
+            "mx",
+            "my",
+            "p",
+            "pt",
+            "pr",
+            "pb",
+            "pl",
+            "px",
+            "py",
+            "className",
+            "style",
+            "children"
+        ]), [ref] = _rest;
+        const classes = className ? `${surface({
+            radius,
+            elevation
+        })} ${className}` : surface({
+            radius,
+            elevation
+        });
+        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
+        }));
+    });
+    Surface.displayName = 'Surface';
+    const surface_Surface = Surface;
+    const components_surface = surface_Surface;
+})();
+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/surface.css

@@ -0,0 +1,28 @@
+._1b2xjv10 {
+  background-color: var(--vinyasa-secondary);
+}
+
+._1b2xjv11 {
+  border-radius: var(--vinyasa-radius-sm);
+}
+
+._1b2xjv12 {
+  border-radius: var(--vinyasa-radius-md);
+}
+
+._1b2xjv13 {
+  border-radius: var(--vinyasa-radius-full);
+}
+
+._1b2xjv14 {
+  box-shadow: var(--vinyasa-elevation-raised);
+}
+
+._1b2xjv15 {
+  box-shadow: var(--vinyasa-elevation-overlay);
+}
+
+._1b2xjv16 {
+  box-shadow: var(--vinyasa-elevation-modal);
+}
+

package/dist/esm/207.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);
+}
+

package/dist/esm/207.js

@@ -0,0 +1,88 @@
+import "./207.css";
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { createRuntimeFn } from "./953.js";
+import { resolveSpacingStyle } from "./474.js";
+var flex = createRuntimeFn({
+    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: []
+});
+const Flex = /*#__PURE__*/ forwardRef(({ 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, ...rest }, ref)=>{
+    const classes = className ? `${flex({
+        direction,
+        align,
+        justify,
+        wrap,
+        gap
+    })} ${className}` : flex({
+        direction,
+        align,
+        justify,
+        wrap,
+        gap
+    });
+    const spacingStyle = resolveSpacingStyle({
+        m,
+        mt,
+        mr,
+        mb,
+        ml,
+        mx,
+        my,
+        p,
+        pt,
+        pr,
+        pb,
+        pl,
+        px,
+        py
+    });
+    return /*#__PURE__*/ jsx(Component, {
+        ref: ref,
+        className: classes,
+        style: {
+            ...spacingStyle,
+            ...style
+        },
+        ...rest,
+        children: children
+    });
+});
+Flex.displayName = 'Flex';
+const flex_Flex = Flex;
+export { flex_Flex };

package/dist/esm/474.js

@@ -0,0 +1,76 @@
+import { themeContract } from "@vinyasa/tokens";
+const space = {
+    1: themeContract.space1,
+    2: themeContract.space2,
+    3: themeContract.space3,
+    4: themeContract.space4,
+    5: themeContract.space5,
+    6: 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;
+};
+export { resolveSpacingStyle };