@telefonica/mistica 15.9.0 → 15.11.0

package/dist/table.css.d.ts

@@ -0,0 +1,13 @@
+export declare const vars: {
+    maxHeight: `var(--${string})` | `var(--${string}, ${string})` | `var(--${string}, ${number})`;
+};
+export declare const table: string;
+export declare const fullWidth: string;
+export declare const collapsedRowsInMobile: string;
+export declare const boxed: string;
+export declare const cellTextAlign: Record<"left" | "right" | "center", string>;
+export declare const scrollContainer: string;
+export declare const scrollOverResponsiveLayout: string;
+export declare const verticalAlign: Record<"top" | "middle", string>;
+export declare const mobileCellHeading: string;
+export declare const collapsedRowTittle: string;

package/dist/table.css.ts.vanilla.css-mistica.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return a;
+    }
+});
+const a = "";

package/dist/table.d.ts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import type { DataAttributes } from './utils/types';
+type TextAlign = 'left' | 'right' | 'center';
+type VerticalAlign = 'top' | 'middle';
+type TableProps = {
+    heading: Array<React.ReactNode>;
+    content?: Array<Array<React.ReactNode>>;
+    boxed?: boolean;
+    emptyCase?: React.ReactNode;
+    /**
+     * In mobile, the table will be scrollable horizontally by default. Alternatively, you can set it to 'collapse-rows', which will
+     * render every row as a card
+     */
+    responsive?: 'scroll' | 'collapse-rows';
+    columnTextAlign?: Array<TextAlign> | TextAlign;
+    rowVerticalAlign?: VerticalAlign;
+    columnWidth?: Array<number | string>;
+    /**
+     * by default, the table expands to all the available width, if you want the table to have the minimum width to fit the rows content, set fullWidth to false.
+     * It's ignored in mobile
+     */
+    fullWidth?: boolean;
+    /**
+     * Limits the height of the table and the content will have vertical scroll.
+     * It's ignored in mobile when responsive move is 'collapse-rows'
+     */
+    maxHeight?: number | string;
+    /**
+     * when rendering the table inside a responsive layout, you can enable this prop to make the table scrollable over the layout paddings
+     */
+    scrollOverResponsiveLayout?: boolean;
+    /** "data-" prefix is automatically added. For example, use "testid" instead of "data-testid" */
+    dataAttributes?: DataAttributes;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+};
+export declare const Table: React.ForwardRefExoticComponent<TableProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/table.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Table", {
+    enumerable: true,
+    get: function() {
+        return ee;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _dom = require("./utils/dom.js");
+const _tablecssmistica = require("./table.css-mistica.js");
+const _skincontractcssmistica = require("./skins/skin-contract.css-mistica.js");
+const _text = require("./text.js");
+const _boxed = require("./boxed.js");
+const _classnames = /*#__PURE__*/ _interop_require_default(require("classnames"));
+const _box = /*#__PURE__*/ _interop_require_default(require("./box.js"));
+const _css = require("./utils/css.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 _interop_require_wildcard(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 = {
+        __proto__: null
+    };
+    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 _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 = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            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 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 = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+const C = "left", ee = /*#__PURE__*/ _react.forwardRef((_param, v)=>{
+    var { dataAttributes: f, heading: n, content: d, boxed: y, responsive: O, fullWidth: s = !0, maxHeight: c, emptyCase: m, columnTextAlign: p = C, rowVerticalAlign: h = "middle", columnWidth: l, scrollOverResponsiveLayout: j } = _param, b = _object_without_properties(_param, [
+        "dataAttributes",
+        "heading",
+        "content",
+        "boxed",
+        "responsive",
+        "fullWidth",
+        "maxHeight",
+        "emptyCase",
+        "columnTextAlign",
+        "rowVerticalAlign",
+        "columnWidth",
+        "scrollOverResponsiveLayout"
+    ]);
+    const u = (a)=>{
+        var _p_a;
+        return Array.isArray(p) ? (_p_a = p[a]) !== null && _p_a !== void 0 ? _p_a : C : p;
+    }, r = O === "collapse-rows", g = /* @__PURE__ */ (0, _jsxruntime.jsxs)("table", {
+        className: (0, _classnames.default)(_tablecssmistica.table, {
+            [_tablecssmistica.boxed]: y,
+            [_tablecssmistica.collapsedRowsInMobile]: r,
+            [_tablecssmistica.fullWidth]: s
+        }),
+        "aria-label": b["aria-label"],
+        "aria-labelledby": b["aria-labelledby"],
+        "aria-describedby": b["aria-describedby"],
+        children: [
+            /* @__PURE__ */ (0, _jsxruntime.jsx)("thead", {
+                children: /* @__PURE__ */ (0, _jsxruntime.jsx)(_text.Text1, {
+                    as: "tr",
+                    medium: !0,
+                    transform: "uppercase",
+                    color: _skincontractcssmistica.vars.colors.textSecondary,
+                    wordBreak: !1,
+                    children: n.map((a, t)=>/* @__PURE__ */ (0, _jsxruntime.jsx)("th", {
+                            scope: "col",
+                            className: (0, _classnames.default)(_tablecssmistica.cellTextAlign[u(t)], _tablecssmistica.verticalAlign[h]),
+                            style: {
+                                minWidth: l == null ? void 0 : l[t],
+                                width: l == null ? void 0 : l[t]
+                            },
+                            children: a
+                        }, t))
+                })
+            }),
+            /* @__PURE__ */ (0, _jsxruntime.jsx)("tbody", {
+                children: d && d.length ? d.map((a, t)=>/* @__PURE__ */ (0, _jsxruntime.jsx)("tr", {
+                        children: a.map((I, o)=>/* @__PURE__ */ (0, _jsxruntime.jsxs)("td", {
+                                className: _tablecssmistica.verticalAlign[h],
+                                children: [
+                                    o !== 0 && r && // this is aria-hidden because screen readers already read the column heading from the th
+                                    /* @__PURE__ */ (0, _jsxruntime.jsx)("div", {
+                                        className: _tablecssmistica.mobileCellHeading,
+                                        "aria-hidden": !0,
+                                        children: /* @__PURE__ */ (0, _jsxruntime.jsx)(_text.Text1, {
+                                            medium: !0,
+                                            color: _skincontractcssmistica.vars.colors.textSecondary,
+                                            children: n[o]
+                                        })
+                                    }),
+                                    /* @__PURE__ */ (0, _jsxruntime.jsx)(_text.Text2, {
+                                        as: "div",
+                                        weight: o === 0 && r ? "medium" : "regular",
+                                        wordBreak: !1,
+                                        children: /* @__PURE__ */ (0, _jsxruntime.jsx)("div", {
+                                            className: (0, _classnames.default)(_tablecssmistica.cellTextAlign[u(o)], {
+                                                [_tablecssmistica.collapsedRowTittle]: o === 0 && r
+                                            }),
+                                            children: I
+                                        })
+                                    })
+                                ]
+                            }, o))
+                    }, t)) : /* @__PURE__ */ (0, _jsxruntime.jsx)("tr", {
+                    children: /* @__PURE__ */ (0, _jsxruntime.jsx)("td", {
+                        colSpan: n.length,
+                        children: typeof m == "string" ? /* @__PURE__ */ (0, _jsxruntime.jsx)(_box.default, {
+                            paddingY: 56,
+                            children: /* @__PURE__ */ (0, _jsxruntime.jsx)(_text.Text2, {
+                                regular: !0,
+                                textAlign: "center",
+                                as: "div",
+                                children: m
+                            })
+                        }) : m
+                    })
+                })
+            })
+        ]
+    }), w = function() {
+        let a = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1;
+        return {
+            className: (0, _classnames.default)(_tablecssmistica.scrollContainer, {
+                [_tablecssmistica.scrollOverResponsiveLayout]: a,
+                [_tablecssmistica.collapsedRowsInMobile]: r,
+                [_tablecssmistica.fullWidth]: s
+            }),
+            style: (0, _css.applyCssVars)({
+                [_tablecssmistica.vars.maxHeight]: typeof c == "number" ? `${c}px` : c !== null && c !== void 0 ? c : "auto"
+            })
+        };
+    };
+    return y ? /* @__PURE__ */ (0, _jsxruntime.jsx)(_boxed.InternalBoxed, {
+        desktopOnly: r,
+        width: "fit-content",
+        maxWidth: "100%",
+        minWidth: {
+            desktop: s ? "100%" : "auto",
+            mobile: r || s ? "100%" : "auto"
+        },
+        ref: v,
+        dataAttributes: _object_spread({
+            "component-name": "Table"
+        }, f),
+        children: /* @__PURE__ */ (0, _jsxruntime.jsx)("div", _object_spread_props(_object_spread({}, w()), {
+            children: g
+        }))
+    }) : /* @__PURE__ */ (0, _jsxruntime.jsx)("div", _object_spread_props(_object_spread({
+        ref: v
+    }, (0, _dom.getPrefixedDataAttributes)(f, "Table"), w(j)), {
+        children: g
+    }));
+});

package/dist/text.d.ts

@@ -10,7 +10,7 @@ export interface TextPresetProps {
     truncate?: boolean | number;
     wordBreak?: boolean;
     hyphens?: 'auto' | 'manual' | 'none';
-    textAlign?: 'center' | 'right';
+    textAlign?: 'center' | 'right' | 'left';
     id?: string;
     as?: React.ComponentType<any> | string;
     role?: string;

package/dist/theme.d.ts

@@ -50,6 +50,21 @@ declare const TEXTS_ES: {
     counterQuantity: string;
     counterMinValue: string;
     counterMaxValue: string;
+    timerDaysShortLabel: string;
+    timerHoursShortLabel: string;
+    timerMinutesShortLabel: string;
+    timerSecondsShortLabel: string;
+    timerAnd: string;
+    timerDayLongLabel: string;
+    timerDaysLongLabel: string;
+    timerHourLongLabel: string;
+    timerHoursLongLabel: string;
+    timerMinuteLongLabel: string;
+    timerMinutesLongLabel: string;
+    timerSecondLongLabel: string;
+    timerSecondsLongLabel: string;
+    timerDisplayMinutesLabel: string;
+    timerDisplaySecondsLabel: string;
 };
 export declare const getTexts: (locale: Locale) => typeof TEXTS_ES;
 export declare const NAVBAR_HEIGHT_MOBILE = 56;
@@ -59,6 +74,10 @@ export declare const dimensions: {
     headerMobileHeight: number;
     headerDesktopHeight: number;
 };
+/**
+ * https://reactrouter.com/en/main/components/link
+ * https://nextjs.org/docs/app/api-reference/components/link
+ */
 type LinkComponent = React.ComponentType<{
     style?: React.CSSProperties;
     className?: string;
@@ -84,6 +103,7 @@ type LinkComponent = React.ComponentType<{
     onClick?: React.MouseEventHandler<HTMLAnchorElement>;
     onKeyDown?: React.KeyboardEventHandler<HTMLAnchorElement>;
     children: React.ReactNode;
+    target?: string;
 }>;
 export declare const getMisticaLinkComponent: (Link?: ThemeConfig['Link']) => LinkComponent;
 export type ColorScheme = 'dark' | 'light' | 'auto';

package/dist/theme.js

@@ -10,19 +10,19 @@ function _export(target, all) {
 }
 _export(exports, {
     NAVBAR_HEIGHT_DESKTOP: function() {
-        return c;
+        return m;
     },
     NAVBAR_HEIGHT_MOBILE: function() {
         return u;
     },
     dimensions: function() {
-        return V;
+        return v;
     },
     getMisticaLinkComponent: function() {
-        return E;
+        return h;
     },
     getTexts: function() {
-        return g;
+        return f;
     }
 });
 const _jsxruntime = require("react/jsx-runtime");
@@ -150,7 +150,22 @@ const l = {
     counterDecreaseLabel: "Disminuir valor",
     counterQuantity: "cantidad",
     counterMinValue: "m\xednimo",
-    counterMaxValue: "m\xe1ximo"
+    counterMaxValue: "m\xe1ximo",
+    timerDaysShortLabel: "d",
+    timerHoursShortLabel: "h",
+    timerMinutesShortLabel: "min",
+    timerSecondsShortLabel: "s",
+    timerAnd: "y",
+    timerDayLongLabel: "d\xeda",
+    timerDaysLongLabel: "d\xedas",
+    timerHourLongLabel: "hora",
+    timerHoursLongLabel: "horas",
+    timerMinuteLongLabel: "minuto",
+    timerMinutesLongLabel: "minutos",
+    timerSecondLongLabel: "segundo",
+    timerSecondsLongLabel: "segundos",
+    timerDisplayMinutesLabel: "min",
+    timerDisplaySecondsLabel: "seg"
 }, i = {
     expirationDatePlaceholder: "MM/YY",
     enablePasswordVisibility: "Show password",
@@ -196,7 +211,22 @@ const l = {
     counterDecreaseLabel: "Decrease value",
     counterQuantity: "quantity",
     counterMinValue: "minimum of",
-    counterMaxValue: "maximum of"
+    counterMaxValue: "maximum of",
+    timerDaysShortLabel: "d",
+    timerHoursShortLabel: "h",
+    timerMinutesShortLabel: "min",
+    timerSecondsShortLabel: "s",
+    timerAnd: "and",
+    timerDayLongLabel: "day",
+    timerDaysLongLabel: "days",
+    timerHourLongLabel: "hour",
+    timerHoursLongLabel: "hours",
+    timerMinuteLongLabel: "minute",
+    timerMinutesLongLabel: "minutes",
+    timerSecondLongLabel: "second",
+    timerSecondsLongLabel: "seconds",
+    timerDisplayMinutesLabel: "min",
+    timerDisplaySecondsLabel: "sec"
 }, s = {
     expirationDatePlaceholder: "MM/JJ",
     enablePasswordVisibility: "Passwort anzeigen",
@@ -242,7 +272,22 @@ const l = {
     counterDecreaseLabel: "Wert verringern",
     counterQuantity: "menge",
     counterMinValue: "minimal",
-    counterMaxValue: "maximal"
+    counterMaxValue: "maximal",
+    timerDaysShortLabel: "Tg.",
+    timerHoursShortLabel: "Std.",
+    timerMinutesShortLabel: "Min.",
+    timerSecondsShortLabel: "Sek.",
+    timerAnd: "und",
+    timerDayLongLabel: "Tag",
+    timerDaysLongLabel: "Tage",
+    timerHourLongLabel: "Stunde",
+    timerHoursLongLabel: "Stunden",
+    timerMinuteLongLabel: "Minute",
+    timerMinutesLongLabel: "Minuten",
+    timerSecondLongLabel: "Sekunde",
+    timerSecondsLongLabel: "Sekunden",
+    timerDisplayMinutesLabel: "Min.",
+    timerDisplaySecondsLabel: "Sek."
 }, d = {
     expirationDatePlaceholder: "MM/AA",
     enablePasswordVisibility: "mostrar senha",
@@ -288,8 +333,23 @@ const l = {
     counterDecreaseLabel: "diminuir valor",
     counterQuantity: "quantidade",
     counterMinValue: "m\xednimo",
-    counterMaxValue: "m\xe1ximo"
-}, g = (e)=>{
+    counterMaxValue: "m\xe1ximo",
+    timerDaysShortLabel: "d",
+    timerHoursShortLabel: "h",
+    timerMinutesShortLabel: "min",
+    timerSecondsShortLabel: "s",
+    timerAnd: "e",
+    timerDayLongLabel: "dia",
+    timerDaysLongLabel: "dias",
+    timerHourLongLabel: "hora",
+    timerHoursLongLabel: "horas",
+    timerMinuteLongLabel: "minuto",
+    timerMinutesLongLabel: "minutos",
+    timerSecondLongLabel: "segundo",
+    timerSecondsLongLabel: "segundos",
+    timerDisplayMinutesLabel: "min",
+    timerDisplaySecondsLabel: "seg"
+}, f = (e)=>{
     switch(e.toLocaleLowerCase().split(/[-_]/)[0]){
         case "es":
             return l;
@@ -302,10 +362,10 @@ const l = {
         default:
             return process.env.NODE_ENV !== "production" && console.error(`Invalid locale: ${e}`), i;
     }
-}, u = 56, c = 80, V = {
+}, u = 56, m = 80, v = {
     headerMobileHeight: u,
-    headerDesktopHeight: c
-}, m = (_param)=>{
+    headerDesktopHeight: m
+}, c = (_param)=>{
     var { to: e, innerRef: r } = _param, a = _object_without_properties(_param, [
         "to",
         "innerRef"
@@ -316,14 +376,14 @@ const l = {
     }, a), {
         children: a.children
     }));
-}, C = (e)=>e, p = (e)=>(_param)=>{
+}, C = (e)=>e, b = (e)=>(_param)=>{
         var { innerRef: r } = _param, a = _object_without_properties(_param, [
             "innerRef"
         ]);
         return /* @__PURE__ */ (0, _jsxruntime.jsx)(e, _object_spread({
             ref: r
         }, a));
-    }, f = (e)=>(_param)=>{
+    }, L = (e)=>(_param)=>{
         var { to: r, innerRef: a, children: t } = _param, n = _object_without_properties(_param, [
             "to",
             "innerRef",
@@ -337,7 +397,7 @@ const l = {
                 children: t
             }))
         });
-    }, b = (e)=>(_param)=>{
+    }, p = (e)=>(_param)=>{
         var { to: r, innerRef: a, children: t } = _param, n = _object_without_properties(_param, [
             "to",
             "innerRef",
@@ -349,19 +409,19 @@ const l = {
         }, n), {
             children: t
         }));
-    }, E = (e)=>{
-    if (!e) return m;
+    }, h = (e)=>{
+    if (!e) return c;
     if (typeof e == "function" || e.$$typeof) return e;
     switch(e.type){
         case "ReactRouter5":
             return C(e.Component);
         case "ReactRouter6":
-            return p(e.Component);
+            return b(e.Component);
         case "Next12":
-            return f(e.Component);
+            return L(e.Component);
         case "Next13":
         case "Next14":
-            return b(e.Component);
+            return p(e.Component);
         default:
             const r = e.type;
             throw new Error(`Invalid Link type: ${r}`);

package/dist/timer.css-mistica.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    boxedTimerDisplayValue: function() {
+        return n;
+    },
+    boxedTimerValueContainer: function() {
+        return y;
+    },
+    boxedTimerValueContainerInverse: function() {
+        return a;
+    },
+    inlineText: function() {
+        return f;
+    },
+    shortLabelText: function() {
+        return _;
+    },
+    timerDisplayValue: function() {
+        return r;
+    },
+    timerWrapper: function() {
+        return i;
+    },
+    unitContainer: function() {
+        return t;
+    }
+});
+require("./sprinkles.css.ts.vanilla.css-mistica.js");
+require("./timer.css.ts.vanilla.css-mistica.js");
+var n = "_18fye848", y = "_18fye84a _1y2v1nfa1 _1y2v1nfba _1y2v1nf7m _1y2v1nf8v _1y2v1nfkb _1y2v1nf6l", a = "_18fye84a _1y2v1nfa1 _1y2v1nfba _1y2v1nf7m _1y2v1nf8v _1y2v1nfkb _1y2v1nf3q", f = "_18fye841", _ = "_18fye841 _1y2v1nfho", r = "_1y2v1nfhk _1y2v1nfhq _1y2v1nfhz", i = "_1y2v1nfho", t = "_18fye841 _1y2v1nfhl _1y2v1nfht";

package/dist/timer.css.d.ts

@@ -0,0 +1,8 @@
+export declare const timerWrapper: string;
+export declare const inlineText: string;
+export declare const unitContainer: string;
+export declare const shortLabelText: string;
+export declare const timerDisplayValue: string;
+export declare const boxedTimerDisplayValue: string;
+export declare const boxedTimerValueContainer: string;
+export declare const boxedTimerValueContainerInverse: string;

package/dist/timer.css.ts.vanilla.css-mistica.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return s;
+    }
+});
+const s = "";

package/dist/timer.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import type { DataAttributes } from './utils/types';
+export type TimeUnit = 'days' | 'hours' | 'minutes' | 'seconds';
+type Label = 'none' | 'short' | 'long';
+export interface RemainingTime {
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+}
+interface BaseProps {
+    endTimestamp: Date | number;
+    minTimeUnit: TimeUnit;
+    maxTimeUnit: TimeUnit;
+    dataAttributes?: DataAttributes;
+    onProgress?: (value: RemainingTime) => void;
+    'aria-label'?: string;
+}
+interface TextTimerProps extends BaseProps {
+    labelType?: Label;
+}
+interface TimerProps extends BaseProps {
+    boxed?: boolean;
+}
+export declare const TextTimer: React.FC<TextTimerProps>;
+export declare const Timer: React.FC<TimerProps>;
+export {};