@prokodo/ui 0.0.9 → 0.0.11

package/dist/components/teaser/Teaser.js

@@ -0,0 +1,102 @@
+import { j as o } from "../../_virtual/jsx-runtime.js";
+import { memo as r } from "react";
+import { create as e } from "../../helpers/bem.js";
+import { isString as h } from "../../helpers/validations.js";
+import { Card as g } from "../card/Card.js";
+import { Headline as v } from "../headline/Headline.js";
+import { Icon as C } from "../icon/Icon.js";
+import { Image as y } from "../image/Image.js";
+import { Lottie as T } from "../lottie/Lottie.js";
+import { RichText as b } from "../rich-text/RichText.js";
+import I from "./Teaser.module.scss.js";
+const s = e(I, "Teaser"), R = r(
+  ({
+    className: f,
+    variant: n = "primary",
+    animation: l,
+    lineClamp: c,
+    align: p,
+    image: N,
+    title: m,
+    content: x,
+    onClick: j,
+    redirect: a,
+    ..._
+  }) => {
+    var i;
+    return /* @__PURE__ */ o.jsxs(
+      g,
+      {
+        variant: n,
+        ..._,
+        className: s(void 0, void 0, f),
+        contentClassName: s("card"),
+        redirect: a,
+        onClick: j,
+        children: [
+          l && /* @__PURE__ */ o.jsx(T, { animationName: l, className: s("animation") }),
+          N && /* @__PURE__ */ o.jsx("div", { className: s("image__wrapper"), children: /* @__PURE__ */ o.jsx(
+            y,
+            {
+              ...N,
+              captionClassName: s("image__caption"),
+              className: s("image"),
+              containerClassName: s("image")
+            }
+          ) }),
+          /* @__PURE__ */ o.jsxs("div", { className: s("card__content"), children: [
+            /* @__PURE__ */ o.jsx(
+              v,
+              {
+                align: p ?? "center",
+                size: "md",
+                type: "h3",
+                ...m,
+                variant: (m == null ? void 0 : m.variant) ?? n,
+                className: s(
+                  "headline",
+                  {
+                    "has-lineClamp": !!c
+                  },
+                  m == null ? void 0 : m.className
+                ),
+                children: m == null ? void 0 : m.content
+              }
+            ),
+            h(x) && /* @__PURE__ */ o.jsx(
+              b,
+              {
+                className: s("content", {
+                  "has-lineClamp": !!c,
+                  [`align-${p}`]: !!p
+                }),
+                children: x
+              }
+            ),
+            h(a == null ? void 0 : a.label) && /* @__PURE__ */ o.jsxs("span", { className: s("link"), children: [
+              /* @__PURE__ */ o.jsx(
+                C,
+                {
+                  color: n,
+                  name: "ArrowRight01Icon",
+                  size: "xs",
+                  ...a == null ? void 0 : a.icon,
+                  className: s(
+                    "link__icon",
+                    void 0,
+                    (i = a == null ? void 0 : a.icon) == null ? void 0 : i.className
+                  )
+                }
+              ),
+              a == null ? void 0 : a.label
+            ] })
+          ] })
+        ]
+      }
+    );
+  }
+);
+R.displayName = "Teaser";
+export {
+  R as Teaser
+};

package/dist/components/teaser/Teaser.module.scss.js

@@ -0,0 +1,23 @@
+const o = "gradientMove", e = "fadeInKeyframe", r = {
+  "prokodo-Teaser": "prokodo-Teaser",
+  "prokodo-Teaser__card": "prokodo-Teaser__card",
+  "prokodo-Teaser__card__content": "prokodo-Teaser__card__content",
+  "prokodo-Teaser__image": "prokodo-Teaser__image",
+  "prokodo-Teaser__image__wrapper": "prokodo-Teaser__image__wrapper",
+  "prokodo-Teaser__image__caption": "prokodo-Teaser__image__caption",
+  "prokodo-Teaser__animation": "prokodo-Teaser__animation",
+  "prokodo-Teaser__headline--has-lineClamp": "prokodo-Teaser__headline--has-lineClamp",
+  "prokodo-Teaser__content": "prokodo-Teaser__content",
+  "prokodo-Teaser__content--has-lineClamp": "prokodo-Teaser__content--has-lineClamp",
+  "prokodo-Teaser__content--align-left": "prokodo-Teaser__content--align-left",
+  "prokodo-Teaser__content--align-right": "prokodo-Teaser__content--align-right",
+  "prokodo-Teaser__link": "prokodo-Teaser__link",
+  "prokodo-Teaser__link__icon": "prokodo-Teaser__link__icon",
+  gradientMove: o,
+  fadeInKeyframe: e
+};
+export {
+  r as default,
+  e as fadeInKeyframe,
+  o as gradientMove
+};

package/dist/components/teaser/index.js

@@ -0,0 +1,4 @@
+import { Teaser as o } from "./Teaser.js";
+export {
+  o as Teaser
+};

package/dist/helpers/bem.js

@@ -0,0 +1,12 @@
+import m from "react-bem-helper";
+const p = "prokodo";
+function l(t, e) {
+  const n = `${p}-${e}`, r = new m({ name: n, outputIsString: !0 });
+  return (s, a, c) => r(s, a, c).split(" ").map(
+    (o) => t[o] !== void 0 && t[o] !== "" ? t[o] : o
+  ).join(" ");
+}
+export {
+  p as COMPANY_PREFIX,
+  l as create
+};

package/dist/helpers/calculation.js

@@ -0,0 +1,4 @@
+const l = (o) => o === void 0 ? 0 : o.split(/\s+/).length;
+export {
+  l as calculateWordCount
+};

package/dist/helpers/validations.js

@@ -0,0 +1,8 @@
+const t = (s) => typeof s == "string" && s.trim() !== "", i = (s) => typeof s == "number", r = (s) => Array.isArray(s) && s.length > 0, n = (s) => s == null, o = (s) => s !== !1 && s !== void 0;
+export {
+  r as isArray,
+  n as isNull,
+  i as isNumber,
+  t as isString,
+  o as isTrue
+};

package/dist/hooks/useGoogleMaps.js

@@ -0,0 +1,19 @@
+import { Loader as s } from "@googlemaps/js-api-loader";
+import { useState as l, useEffect as n } from "react";
+const m = (o, e) => {
+  const [a, t] = l(!1);
+  return n(() => {
+    new s({
+      apiKey: o,
+      version: "weekly",
+      libraries: ["maps"]
+    }).importLibrary("marker").then(() => {
+      t(!0);
+    }).catch((r) => {
+      throw console.error("Error loading Google Maps", r), new Error("Error loading Google Map: ", r);
+    });
+  }, [o, e]), a;
+};
+export {
+  m as useGoogleMaps
+};

package/dist/index.js

@@ -0,0 +1,86 @@
+import { Accordion as e } from "./components/accordion/Accordion.js";
+import { Animated as m } from "./components/animated/Animated.js";
+import { AnimatedText as x } from "./components/animatedText/AnimatedText.js";
+import { Avatar as a } from "./components/avatar/Avatar.js";
+import { BaseLink as n } from "./components/base-link/BaseLink.js";
+import { Button as s } from "./components/button/Button.js";
+import { Calendly as c } from "./components/calendly/Calendly.js";
+import { Card as g } from "./components/card/Card.js";
+import { Carousel as I } from "./components/carousel/Carousel.js";
+import { Chip as P } from "./components/chip/Chip.js";
+import { DatePicker as S } from "./components/datePicker/DatePicker.js";
+import { Dialog as A } from "./components/dialog/Dialog.js";
+import { Drawer as w } from "./components/drawer/Drawer.js";
+import { Form as R } from "./components/form/Form.js";
+import { FormResponse as B } from "./components/form/FormResponse.js";
+import { Grid as G } from "./components/grid/Grid.js";
+import { GridRow as v } from "./components/grid/GridRow.js";
+import { Headline as H } from "./components/headline/Headline.js";
+import { Icon as O } from "./components/icon/Icon.js";
+import { Image as j } from "./components/image/Image.js";
+import { ImageText as z } from "./components/image-text/ImageText.js";
+import { Input as J } from "./components/input/Input.js";
+import { InputOTP as N } from "./components/inputOTP/InputOTP.js";
+import { Label as V } from "./components/label/Label.js";
+import { Link as Y } from "./components/link/Link.js";
+import { List as _ } from "./components/list/List.js";
+import { Loading as oo } from "./components/loading/Loading.js";
+import { Lottie as eo } from "./components/lottie/Lottie.js";
+import { Map as mo } from "./components/map/Map.js";
+import { PostItem as xo } from "./components/post-item/PostItem.js";
+import { PostTeaser as ao } from "./components/post-teaser/PostTeaser.js";
+import { PostWidget as no } from "./components/post-widget/PostWidget.js";
+import { PostWidgetCarousel as lo } from "./components/post-widget-carousel/PostWidgetCarousel.js";
+import { Quote as To } from "./components/quote/Quote.js";
+import { RichText as uo } from "./components/rich-text/RichText.js";
+import { Select as Lo } from "./components/select/Select.js";
+import { Skeleton as Co } from "./components/skeleton/Skeleton.js";
+import { Slider as ko } from "./components/slider/Slider.js";
+import { Stepper as ho } from "./components/stepper/Stepper.js";
+import { Switch as Do } from "./components/switch/Switch.js";
+import { Table as bo } from "./components/table/Table.js";
+import { Teaser as Fo } from "./components/teaser/Teaser.js";
+export {
+  e as Accordion,
+  m as Animated,
+  x as AnimatedText,
+  a as Avatar,
+  n as BaseLink,
+  s as Button,
+  c as Calendly,
+  g as Card,
+  I as Carousel,
+  P as Chip,
+  S as DatePicker,
+  A as Dialog,
+  w as Drawer,
+  R as Form,
+  B as FormResponse,
+  G as Grid,
+  v as GridRow,
+  H as Headline,
+  O as Icon,
+  j as Image,
+  z as ImageText,
+  J as Input,
+  N as InputOTP,
+  V as Label,
+  Y as Link,
+  _ as List,
+  oo as Loading,
+  eo as Lottie,
+  mo as Map,
+  xo as PostItem,
+  ao as PostTeaser,
+  no as PostWidget,
+  lo as PostWidgetCarousel,
+  To as Quote,
+  uo as RichText,
+  Lo as Select,
+  Co as Skeleton,
+  ko as Slider,
+  ho as Stepper,
+  Do as Switch,
+  bo as Table,
+  Fo as Teaser
+};

package/dist/node_modules/.pnpm/@floating-ui_core@1.7.0/node_modules/@floating-ui/core/dist/floating-ui.core.js

@@ -0,0 +1,353 @@
+import { evaluate as D, getSide as E, getSideAxis as C, getOppositePlacement as H, getExpandedPlacements as J, getOppositeAxisPlacements as K, getAlignmentSides as N, clamp as X, getAlignment as _, getPaddingObject as Q, rectToClientRect as Y, getOppositeAxis as U, getAlignmentAxis as W, getAxisLength as Z } from "../../../../../@floating-ui_utils@0.2.9/node_modules/@floating-ui/utils/dist/floating-ui.utils.js";
+function $(l, s, f) {
+  let {
+    reference: t,
+    floating: a
+  } = l;
+  const e = C(s), c = W(s), o = Z(c), x = E(s), u = e === "y", m = t.x + t.width / 2 - a.width / 2, n = t.y + t.height / 2 - a.height / 2, r = t[o] / 2 - a[o] / 2;
+  let i;
+  switch (x) {
+    case "top":
+      i = {
+        x: m,
+        y: t.y - a.height
+      };
+      break;
+    case "bottom":
+      i = {
+        x: m,
+        y: t.y + t.height
+      };
+      break;
+    case "right":
+      i = {
+        x: t.x + t.width,
+        y: n
+      };
+      break;
+    case "left":
+      i = {
+        x: t.x - a.width,
+        y: n
+      };
+      break;
+    default:
+      i = {
+        x: t.x,
+        y: t.y
+      };
+  }
+  switch (_(s)) {
+    case "start":
+      i[c] -= r * (f && u ? -1 : 1);
+      break;
+    case "end":
+      i[c] += r * (f && u ? -1 : 1);
+      break;
+  }
+  return i;
+}
+const nt = async (l, s, f) => {
+  const {
+    placement: t = "bottom",
+    strategy: a = "absolute",
+    middleware: e = [],
+    platform: c
+  } = f, o = e.filter(Boolean), x = await (c.isRTL == null ? void 0 : c.isRTL(s));
+  let u = await c.getElementRects({
+    reference: l,
+    floating: s,
+    strategy: a
+  }), {
+    x: m,
+    y: n
+  } = $(u, t, x), r = t, i = {}, d = 0;
+  for (let y = 0; y < o.length; y++) {
+    const {
+      name: w,
+      fn: p
+    } = o[y], {
+      x: v,
+      y: A,
+      data: b,
+      reset: g
+    } = await p({
+      x: m,
+      y: n,
+      initialPlacement: t,
+      placement: r,
+      strategy: a,
+      middlewareData: i,
+      rects: u,
+      platform: c,
+      elements: {
+        reference: l,
+        floating: s
+      }
+    });
+    m = v ?? m, n = A ?? n, i = {
+      ...i,
+      [w]: {
+        ...i[w],
+        ...b
+      }
+    }, g && d <= 50 && (d++, typeof g == "object" && (g.placement && (r = g.placement), g.rects && (u = g.rects === !0 ? await c.getElementRects({
+      reference: l,
+      floating: s,
+      strategy: a
+    }) : g.rects), {
+      x: m,
+      y: n
+    } = $(u, r, x)), y = -1);
+  }
+  return {
+    x: m,
+    y: n,
+    placement: r,
+    strategy: a,
+    middlewareData: i
+  };
+};
+async function q(l, s) {
+  var f;
+  s === void 0 && (s = {});
+  const {
+    x: t,
+    y: a,
+    platform: e,
+    rects: c,
+    elements: o,
+    strategy: x
+  } = l, {
+    boundary: u = "clippingAncestors",
+    rootBoundary: m = "viewport",
+    elementContext: n = "floating",
+    altBoundary: r = !1,
+    padding: i = 0
+  } = D(s, l), d = Q(i), w = o[r ? n === "floating" ? "reference" : "floating" : n], p = Y(await e.getClippingRect({
+    element: (f = await (e.isElement == null ? void 0 : e.isElement(w))) == null || f ? w : w.contextElement || await (e.getDocumentElement == null ? void 0 : e.getDocumentElement(o.floating)),
+    boundary: u,
+    rootBoundary: m,
+    strategy: x
+  })), v = n === "floating" ? {
+    x: t,
+    y: a,
+    width: c.floating.width,
+    height: c.floating.height
+  } : c.reference, A = await (e.getOffsetParent == null ? void 0 : e.getOffsetParent(o.floating)), b = await (e.isElement == null ? void 0 : e.isElement(A)) ? await (e.getScale == null ? void 0 : e.getScale(A)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, g = Y(e.convertOffsetParentRelativeRectToViewportRelativeRect ? await e.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: o,
+    rect: v,
+    offsetParent: A,
+    strategy: x
+  }) : v);
+  return {
+    top: (p.top - g.top + d.top) / b.y,
+    bottom: (g.bottom - p.bottom + d.bottom) / b.y,
+    left: (p.left - g.left + d.left) / b.x,
+    right: (g.right - p.right + d.right) / b.x
+  };
+}
+const it = function(l) {
+  return l === void 0 && (l = {}), {
+    name: "flip",
+    options: l,
+    async fn(s) {
+      var f, t;
+      const {
+        placement: a,
+        middlewareData: e,
+        rects: c,
+        initialPlacement: o,
+        platform: x,
+        elements: u
+      } = s, {
+        mainAxis: m = !0,
+        crossAxis: n = !0,
+        fallbackPlacements: r,
+        fallbackStrategy: i = "bestFit",
+        fallbackAxisSideDirection: d = "none",
+        flipAlignment: y = !0,
+        ...w
+      } = D(l, s);
+      if ((f = e.arrow) != null && f.alignmentOffset)
+        return {};
+      const p = E(a), v = C(o), A = E(o) === o, b = await (x.isRTL == null ? void 0 : x.isRTL(u.floating)), g = r || (A || !y ? [H(o)] : J(o)), V = d !== "none";
+      !r && V && g.push(...K(o, y, d, b));
+      const z = [o, ...g], L = await q(s, w), T = [];
+      let O = ((t = e.flip) == null ? void 0 : t.overflows) || [];
+      if (m && T.push(L[p]), n) {
+        const k = N(a, c, b);
+        T.push(L[k[0]], L[k[1]]);
+      }
+      if (O = [...O, {
+        placement: a,
+        overflows: T
+      }], !T.every((k) => k <= 0)) {
+        var F, B;
+        const k = (((F = e.flip) == null ? void 0 : F.index) || 0) + 1, M = z[k];
+        if (M) {
+          var j;
+          const P = n === "alignment" ? v !== C(M) : !1, h = ((j = O[0]) == null ? void 0 : j.overflows[0]) > 0;
+          if (!P || h)
+            return {
+              data: {
+                index: k,
+                overflows: O
+              },
+              reset: {
+                placement: M
+              }
+            };
+        }
+        let S = (B = O.filter((P) => P.overflows[0] <= 0).sort((P, h) => P.overflows[1] - h.overflows[1])[0]) == null ? void 0 : B.placement;
+        if (!S)
+          switch (i) {
+            case "bestFit": {
+              var I;
+              const P = (I = O.filter((h) => {
+                if (V) {
+                  const R = C(h.placement);
+                  return R === v || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  R === "y";
+                }
+                return !0;
+              }).map((h) => [h.placement, h.overflows.filter((R) => R > 0).reduce((R, G) => R + G, 0)]).sort((h, R) => h[1] - R[1])[0]) == null ? void 0 : I[0];
+              P && (S = P);
+              break;
+            }
+            case "initialPlacement":
+              S = o;
+              break;
+          }
+        if (a !== S)
+          return {
+            reset: {
+              placement: S
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+async function tt(l, s) {
+  const {
+    placement: f,
+    platform: t,
+    elements: a
+  } = l, e = await (t.isRTL == null ? void 0 : t.isRTL(a.floating)), c = E(f), o = _(f), x = C(f) === "y", u = ["left", "top"].includes(c) ? -1 : 1, m = e && x ? -1 : 1, n = D(s, l);
+  let {
+    mainAxis: r,
+    crossAxis: i,
+    alignmentAxis: d
+  } = typeof n == "number" ? {
+    mainAxis: n,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: n.mainAxis || 0,
+    crossAxis: n.crossAxis || 0,
+    alignmentAxis: n.alignmentAxis
+  };
+  return o && typeof d == "number" && (i = o === "end" ? d * -1 : d), x ? {
+    x: i * m,
+    y: r * u
+  } : {
+    x: r * u,
+    y: i * m
+  };
+}
+const st = function(l) {
+  return l === void 0 && (l = 0), {
+    name: "offset",
+    options: l,
+    async fn(s) {
+      var f, t;
+      const {
+        x: a,
+        y: e,
+        placement: c,
+        middlewareData: o
+      } = s, x = await tt(s, l);
+      return c === ((f = o.offset) == null ? void 0 : f.placement) && (t = o.arrow) != null && t.alignmentOffset ? {} : {
+        x: a + x.x,
+        y: e + x.y,
+        data: {
+          ...x,
+          placement: c
+        }
+      };
+    }
+  };
+}, ot = function(l) {
+  return l === void 0 && (l = {}), {
+    name: "shift",
+    options: l,
+    async fn(s) {
+      const {
+        x: f,
+        y: t,
+        placement: a
+      } = s, {
+        mainAxis: e = !0,
+        crossAxis: c = !1,
+        limiter: o = {
+          fn: (w) => {
+            let {
+              x: p,
+              y: v
+            } = w;
+            return {
+              x: p,
+              y: v
+            };
+          }
+        },
+        ...x
+      } = D(l, s), u = {
+        x: f,
+        y: t
+      }, m = await q(s, x), n = C(E(a)), r = U(n);
+      let i = u[r], d = u[n];
+      if (e) {
+        const w = r === "y" ? "top" : "left", p = r === "y" ? "bottom" : "right", v = i + m[w], A = i - m[p];
+        i = X(v, i, A);
+      }
+      if (c) {
+        const w = n === "y" ? "top" : "left", p = n === "y" ? "bottom" : "right", v = d + m[w], A = d - m[p];
+        d = X(v, d, A);
+      }
+      const y = o.fn({
+        ...s,
+        [r]: i,
+        [n]: d
+      });
+      return {
+        ...y,
+        data: {
+          x: y.x - f,
+          y: y.y - t,
+          enabled: {
+            [r]: e,
+            [n]: c
+          }
+        }
+      };
+    }
+  };
+};
+export {
+  nt as computePosition,
+  q as detectOverflow,
+  it as flip,
+  st as offset,
+  Y as rectToClientRect,
+  ot as shift
+};