@ovotech/element-native 0.0.1 → 0.0.2

package/dist/esm/theme/create-theme.js

@@ -0,0 +1,426 @@
+import deepMerge from 'deepmerge';
+export var defaultTokens = {
+    borderWidths: {
+        standard: '1px',
+        heavy: '2px',
+        heavier: '4px',
+    },
+    radii: {
+        standard: '4px',
+    },
+    shadows: {
+        standard: {
+            color: '#000',
+            offset: '1px',
+            opacity: 0.1,
+            radius: '6px',
+            elevation: 3,
+        },
+    },
+    breakpoints: { small: 480, medium: 768, large: 1208 },
+    space: {
+        1: '4px',
+        2: '8px',
+        3: '12px',
+        4: '16px',
+        5: '20px',
+        6: '24px',
+        7: '28px',
+        8: '32px',
+        9: '36px',
+        10: '40px',
+        11: '44px',
+        12: '48px',
+    },
+    fonts: {
+        display: 'Arial',
+        body: 'Arial',
+        monospace: 'Courier',
+    },
+    lineHeights: {
+        standard: 1.5,
+    },
+    fontSizes: ['12px', '14px', '16px', '20px', '24px', '28px', '32px'],
+    fontWeights: {
+        normal: 400,
+        bold: 700,
+        semiBold: 600,
+    },
+    colors: {
+        primary: '#0C7494',
+        primaryAlt: '#096885',
+        primaryContrast: '#FFFFFF',
+        primaryMuted: '#F3F7F9',
+        error: '#C7153E',
+        errorAlt: '#AE0A30',
+        errorContrast: '#FFFFFF',
+        errorMuted: '#FCF3F5',
+        info: '#147D88',
+        infoAlt: '#05696C',
+        infoContrast: '#FFFFFF',
+        infoMuted: '#F2F7F8',
+        warning: '#C64A18',
+        warningAlt: '#B74E08',
+        warningContrast: '#FFFFFF',
+        warningMuted: '#FDF7F3',
+        success: '#258244',
+        successAlt: '#1E6937',
+        successContrast: '#FFFFFF',
+        successMuted: '#F4F9F6',
+        focus: '#2A71BE',
+        canvas: '#FFFFFF',
+        body: '#555C6B',
+        heading: '#2F3749',
+        border: '#2F3749',
+        canvasMuted: '#F9F9F9',
+        borderMuted: '#D9D9D9',
+    },
+    responsiveFontSizes: {
+        small: ['12px', '14px'],
+        body: ['14px', '16px'],
+        level1: ['28px', '32px'],
+        level2: ['24px', '28px'],
+        level3: ['20px', '24px'],
+        level4: ['16px', '20px'],
+    },
+};
+export function createTheme(customTheme, additional) {
+    var mergeOptions = { arrayMerge: function (_, source) { return source; } };
+    var customThemeWithAdditional = deepMerge(customTheme, additional || {}, mergeOptions);
+    var theme = deepMerge(defaultTokens, customThemeWithAdditional, mergeOptions);
+    var fontSizes = theme.fontSizes, breakpoints = theme.breakpoints, colors = theme.colors, fontWeights = theme.fontWeights, fonts = theme.fonts, lineHeights = theme.lineHeights, space = theme.space, radii = theme.radii, shadows = theme.shadows, borderWidths = theme.borderWidths, responsiveFontSizes = theme.responsiveFontSizes;
+    return deepMerge({
+        field: {
+            fontFamily: fonts.body,
+            fontSize: responsiveFontSizes.body,
+            lineHeight: lineHeights.standard,
+            dateWidth: '265px',
+            gap: space[2],
+            error: {
+                color: colors.error,
+                fontWeight: fontWeights.bold,
+            },
+            hint: {
+                fontWeight: fontWeights.normal,
+                color: colors.body,
+            },
+            label: {
+                color: colors.heading,
+                fontWeight: fontWeights.bold,
+            },
+            subLabel: {
+                color: colors.heading,
+                fontWeight: fontWeights.semiBold,
+            },
+            legend: {
+                marginBottom: space[1],
+            },
+            errorIndent: {
+                borderWidth: space[1],
+                borderRadius: radii.standard,
+            },
+        },
+        focusRing: {
+            color: colors.focus,
+            width: borderWidths.heavy,
+            distance: borderWidths.heavy,
+        },
+        input: {
+            fontFamily: fonts.body,
+            fontSize: responsiveFontSizes.body,
+            color: colors.body,
+            lineHeight: lineHeights.standard,
+            fontWeight: fontWeights.normal,
+            height: space[12],
+            borderColor: colors.border,
+            borderWidth: borderWidths.standard,
+            background: colors.canvas,
+            padding: space[2],
+            borderRadius: radii.standard,
+            error: {
+                borderWidth: borderWidths.heavy,
+                color: colors.error,
+            },
+            icon: {
+                size: space[4],
+            },
+        },
+        card: {
+            background: colors.canvas,
+            borderWidth: borderWidths.standard,
+            borderColor: colors.borderMuted,
+            borderRadius: radii.standard,
+            shadow: shadows.standard,
+            padding: [space[4], space[8]],
+        },
+        badge: {
+            fontWeight: fontWeights.bold,
+            lineHeight: lineHeights.standard,
+            paddingVertical: space[1],
+            paddingHorizontal: space[2],
+            borderRadius: radii.standard,
+            borderWidth: borderWidths.standard,
+            fontSize: responsiveFontSizes.small,
+            variants: {
+                default: {
+                    background: colors.primaryMuted,
+                    foreground: colors.primary,
+                    borderColor: colors.primary,
+                },
+                error: {
+                    background: colors.errorMuted,
+                    foreground: colors.error,
+                    borderColor: colors.error,
+                },
+                success: {
+                    background: colors.successMuted,
+                    foreground: colors.success,
+                    borderColor: colors.success,
+                },
+                info: {
+                    background: colors.infoMuted,
+                    foreground: colors.info,
+                    borderColor: colors.info,
+                },
+                warning: {
+                    background: colors.warningMuted,
+                    foreground: colors.warning,
+                    borderColor: colors.warning,
+                },
+            },
+        },
+        cta: {
+            fontSize: responsiveFontSizes.body,
+            fontWeight: fontWeights.bold,
+            font: fonts.display,
+            lineHeight: lineHeights.standard,
+            paddingVertical: space[2],
+            paddingHorizontal: space[4],
+            borderRadius: radii.standard,
+            borderWidth: borderWidths.standard,
+            iconGap: space[1],
+            minHeight: space[12],
+            variants: {
+                primary: {
+                    background: colors.primary,
+                    foreground: colors.primaryContrast,
+                    border: colors.primary,
+                },
+                secondary: {
+                    background: colors.primaryContrast,
+                    foreground: colors.primary,
+                    border: colors.primary,
+                },
+                destructive: {
+                    background: colors.error,
+                    foreground: colors.errorContrast,
+                    border: colors.error,
+                },
+            },
+        },
+        checkbox: {
+            touchSize: space[12],
+            size: space[8],
+            checkSize: space[6],
+            gap: space[2],
+            paddingTop: space[3],
+            borderWidth: borderWidths.heavy,
+            borderColor: colors.border,
+            borderRadius: radii.standard,
+            background: colors.canvas,
+            checkColor: colors.primary,
+            errorColor: colors.error,
+        },
+        notification: {
+            borderRadius: radii.standard,
+            borderWidth: borderWidths.heavy,
+            borderColor: colors.error,
+            background: colors.errorMuted,
+            padding: [space[3], space[6]],
+            dismiss: {
+                touchSize: space[12],
+                size: space[4],
+                icon: 'cross',
+                color: colors.heading,
+            },
+            variants: {
+                error: {
+                    borderColor: colors.error,
+                    background: colors.errorMuted,
+                },
+                success: {
+                    borderColor: colors.success,
+                    background: colors.successMuted,
+                },
+                info: {
+                    borderColor: colors.info,
+                    background: colors.infoMuted,
+                },
+                warning: {
+                    borderColor: colors.warning,
+                    background: colors.warningMuted,
+                },
+            },
+        },
+        text: {
+            fontFamily: fonts.body,
+            lineHeight: lineHeights.standard,
+            fontWeight: fontWeights.normal,
+            color: colors.body,
+            p: {
+                fontSize: responsiveFontSizes.body,
+                marginTop: [space[2], space[3]],
+                marginBottom: [space[2], space[3]],
+            },
+            small: {
+                fontSize: responsiveFontSizes.small,
+            },
+            strong: {
+                fontWeight: fontWeights.bold,
+            },
+        },
+        list: {
+            marginTop: [space[2], space[3]],
+            marginBottom: [space[2], space[3]],
+            marginLeft: space[6],
+            listItem: {
+                fontSize: responsiveFontSizes.body,
+                marginVertical: 2,
+                bulletGap: space[2],
+                bulletWidth: space[4],
+            },
+            descriptionTerm: {
+                color: colors.heading,
+                fontWeight: fontWeights.bold,
+                marginTop: [space[3], space[4]],
+                marginBottom: [space[1], space[1]],
+            },
+        },
+        textLink: {
+            color: colors.primary,
+            fontWeight: fontWeights.normal,
+        },
+        heading: {
+            fontFamily: fonts.display,
+            lineHeight: lineHeights.standard,
+            fontWeight: fontWeights.bold,
+            color: colors.heading,
+            heading1: {
+                fontSize: responsiveFontSizes.level1,
+                marginTop: [space[8], space[12]],
+                marginBottom: [space[2], space[3]],
+            },
+            heading2: {
+                fontSize: responsiveFontSizes.level2,
+                marginTop: [space[6], space[8]],
+                marginBottom: [space[2], space[3]],
+            },
+            heading3: {
+                fontSize: responsiveFontSizes.level3,
+                marginTop: [space[4], space[6]],
+                marginBottom: [space[2], space[3]],
+            },
+            heading4: {
+                fontSize: responsiveFontSizes.level4,
+                marginTop: [space[3], space[4]],
+                marginBottom: [space[2], space[3]],
+            },
+        },
+        shadows: shadows,
+        radii: radii,
+        radio: {
+            touchSize: space[12],
+            size: space[8],
+            dotSize: space[5],
+            gap: space[2],
+            paddingTop: space[3],
+            borderWidth: borderWidths.heavy,
+            borderColor: colors.border,
+            background: colors.canvas,
+            dotColor: colors.primary,
+            errorColor: colors.error,
+        },
+        fontWeights: fontWeights,
+        fontSizes: fontSizes,
+        fonts: fonts,
+        responsiveFontSizes: responsiveFontSizes,
+        colors: colors,
+        borderWidths: borderWidths,
+        breakpoints: breakpoints,
+        lineHeights: lineHeights,
+        space: space,
+        grid: {
+            maxWidth: breakpoints.large + 'px',
+            gutter: [space[4], space[8]],
+        },
+        disclosure: {
+            iconGap: [space[1], space[2]],
+            panelGap: [space[2], space[3]],
+            lineIndent: {
+                borderRadius: radii.standard,
+                width: borderWidths.heavier,
+                backgroundColor: colors.borderMuted,
+            },
+        },
+        dataTable: {
+            borderWidth: borderWidths.standard,
+            borderRadius: radii.standard,
+            borderColor: colors.borderMuted,
+            tableHeader: {
+                color: colors.heading,
+                backgroundColor: colors.canvas,
+                borderWidth: borderWidths.standard,
+                borderColor: colors.border,
+                fontWeight: fontWeights.bold,
+            },
+            tableCaption: {
+                color: colors.heading,
+                fontWeight: fontWeights.bold,
+                paddingVertical: space[3],
+                paddingHorizontal: space[3],
+            },
+            tableCell: {
+                color: colors.body,
+                borderWidth: borderWidths.standard,
+                borderColor: colors.borderMuted,
+                paddingVertical: space[3],
+                paddingHorizontal: space[3],
+            },
+            tableRow: {
+                backgroundColor: colors.canvasMuted,
+                stripeColor: colors.canvas,
+            },
+        },
+        accordion: {
+            header: {
+                color: colors.primary,
+                paddingVertical: [space[3], space[5]],
+                iconSize: space[4],
+                iconGap: space[3],
+            },
+        },
+        tabs: {
+            tab: {
+                borderTopWidth: borderWidths.heavier,
+                fontSize: responsiveFontSizes.body,
+                fontWeight: fontWeights.bold,
+                fontFamily: fonts.display,
+                lineHeight: lineHeights.standard,
+                paddingHorizontal: [space[4], space[4]],
+                paddingVertical: [space[3], space[3]],
+                active: {
+                    borderTopColor: colors.primary,
+                    foregroundColor: colors.heading,
+                    backgroundColor: colors.canvas,
+                },
+                inactive: {
+                    foregroundColor: colors.primary,
+                    backgroundColor: colors.canvasMuted,
+                },
+                hover: {
+                    foregroundColor: colors.primaryAlt,
+                },
+            },
+        },
+    }, theme, mergeOptions);
+}

package/dist/esm/theme/index.js

@@ -0,0 +1,8 @@
+import { pxToNumber } from '../utils';
+import { createTheme } from './create-theme';
+export * from './theme';
+export * from './create-theme';
+export var theme = createTheme({});
+export var calculateLineHeight = function (size, lineHeight) {
+    return pxToNumber(size) * (lineHeight || 1) + 'px';
+};

package/dist/esm/theme/theme.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/index.js

@@ -0,0 +1 @@
+export * from './utils';

package/dist/esm/utils/utils.js

@@ -0,0 +1,93 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import React, { forwardRef, Children, } from 'react';
+import { useBreakpoint } from '../hooks';
+function mergeRefs(ref1, ref2) {
+    return function (element) {
+        assignRef(ref1, element);
+        assignRef(ref2, element);
+    };
+}
+function assignRef(ref, element) {
+    if (typeof ref === 'function') {
+        ref(element);
+    }
+    else if (ref) {
+        // @ts-ignore
+        ref.current = element;
+    }
+}
+function getText(children) {
+    if (!Boolean(children) && typeof children !== 'number') {
+        return '';
+    }
+    if (typeof children === 'object' && children.props) {
+        return Children.map(children.props.children, function (child) {
+            return getText(child);
+        }).join('');
+    }
+    return String(children);
+}
+function pxToNumber(px) {
+    return parseFloat(px);
+}
+function styledComponentWithBreakpoints(Component) {
+    return forwardRef(function (props, ref) {
+        var breakpoints = useBreakpoint();
+        // @ts-ignore.
+        return React.createElement(Component, __assign({}, props, breakpoints, { ref: ref }));
+    });
+}
+function responsiveStyle(property, value, breakpoints, formatter) {
+    var values;
+    if (Array.isArray(value)) {
+        values = value;
+    }
+    else {
+        values = [value];
+    }
+    var ascMediaQueries = [
+        breakpoints.smallAndUp,
+        breakpoints.mediumAndUp,
+        breakpoints.largeAndUp,
+    ];
+    var base = values[0], rest = values.slice(1);
+    return rest.reduce(function (acc, val, i) {
+        return ascMediaQueries[i]
+            ? "".concat(property, ": ").concat(formatter ? formatter(val) : val, ";")
+            : acc;
+    }, "".concat(property, ": ").concat(formatter ? formatter(base) : base, ";"));
+}
+function getErrorMessage(id, errors) {
+    return (errors.find(function (_a) {
+        var errorId = _a.id;
+        return id === errorId;
+    }) || { message: null })
+        .message;
+}
+function callAll() {
+    var fns = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        fns[_i] = arguments[_i];
+    }
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return fns.forEach(function (fn) { return fn && fn.apply(void 0, args); });
+    };
+}
+function filterChildrenByType(children, type) {
+    return Children.toArray(children).filter(function (child) { return (child === null || child === void 0 ? void 0 : child.type) === type; });
+}
+export { styledComponentWithBreakpoints, responsiveStyle, pxToNumber, mergeRefs, getText, getErrorMessage, callAll, filterChildrenByType, };

package/dist/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './use-full-width';
+export * from './use-breakpoint';

package/dist/hooks/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./use-full-width"), exports);
+__exportStar(require("./use-breakpoint"), exports);

package/dist/hooks/use-breakpoint.d.ts

@@ -0,0 +1,7 @@
+export declare type BreakpointNames = 'smallAndUp' | 'mediumAndUp' | 'largeAndUp';
+export declare type Breakpoints = Record<BreakpointNames, boolean>;
+export declare const useBreakpoint: () => {
+    smallAndUp: boolean;
+    mediumAndUp: boolean;
+    largeAndUp: boolean;
+};

package/dist/hooks/use-breakpoint.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBreakpoint = void 0;
+var react_1 = require("react");
+var react_native_1 = require("react-native");
+var styled_native_1 = require("../styled.native");
+var useBreakpoint = function () {
+    var breakpoints = (0, react_1.useContext)(styled_native_1.ThemeContext).breakpoints;
+    var width = (0, react_native_1.useWindowDimensions)().width;
+    return {
+        smallAndUp: width >= breakpoints.small,
+        mediumAndUp: width >= breakpoints.medium,
+        largeAndUp: width >= breakpoints.large,
+    };
+};
+exports.useBreakpoint = useBreakpoint;

package/dist/hooks/use-full-width.d.ts

@@ -0,0 +1,2 @@
+export declare type FullWidthOptions = 'always' | 'never' | 'small';
+export declare const useFullWidth: (fullWidth?: FullWidthOptions) => boolean;

package/dist/hooks/use-full-width.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFullWidth = void 0;
+var react_1 = require("react");
+var use_breakpoint_1 = require("./use-breakpoint");
+var useFullWidth = function (fullWidth) {
+    if (fullWidth === void 0) { fullWidth = 'small'; }
+    var _a = (0, react_1.useState)(true), isFullWidth = _a[0], setIsfullWidth = _a[1];
+    var smallAndUp = (0, use_breakpoint_1.useBreakpoint)().smallAndUp;
+    (0, react_1.useEffect)(function () {
+        var values = {
+            small: !smallAndUp,
+            always: true,
+            never: false,
+        };
+        setIsfullWidth(values[fullWidth]);
+    }, [isFullWidth, smallAndUp, setIsfullWidth]);
+    return isFullWidth;
+};
+exports.useFullWidth = useFullWidth;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './components';
+export * from './theme';
+export * from './utils';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./components"), exports);
+__exportStar(require("./theme"), exports);
+__exportStar(require("./utils"), exports);

package/dist/providers/IconsProvider.d.ts

@@ -0,0 +1,8 @@
+import { PropsWithChildren } from 'react';
+import { IconsType } from './types';
+declare const defaultIcons: IconsType;
+declare function useIcons<T extends IconsType = {}>(): IconsType & T;
+declare function IconsProvider({ children, icons, }: PropsWithChildren<{
+    icons?: IconsType;
+}>): JSX.Element;
+export { useIcons, IconsProvider, defaultIcons };