@genai-fi/base 3.0.1

package/dist/components/QRCode/QRCode.js

@@ -0,0 +1,61 @@
+import { jsxs as i, jsx as e } from "react/jsx-runtime";
+import { useRef as h, useState as m, useEffect as u, Suspense as v } from "react";
+import { q as p, s as o, D as b } from "../../DialogQR-BU45QB3i.js";
+function q({ url: a, size: r, code: c, label: l, dialog: d }) {
+  const t = h(null), [f, n] = m(!1);
+  return u(() => {
+    t.current && p.toCanvas(t.current, a, { width: r === "large" ? 350 : r === "normal" ? 250 : 164 }).catch(
+      (s) => console.error(s)
+    );
+  }, [a, r]), d ? /* @__PURE__ */ i("div", { className: o.container, children: [
+    /* @__PURE__ */ e(
+      "canvas",
+      {
+        "aria-label": "QR code, click to expand it",
+        role: "button",
+        width: 164,
+        height: 164,
+        ref: t,
+        onClick: () => n(!0),
+        tabIndex: 0,
+        className: o.canvas,
+        "data-testid": "qr-code-canvas",
+        onKeyDown: (s) => {
+          s.key === "Enter" && n(!0);
+        }
+      }
+    ),
+    /* @__PURE__ */ e(v, { children: /* @__PURE__ */ e(
+      b,
+      {
+        url: a,
+        open: f,
+        onClose: () => n(!1)
+      }
+    ) })
+  ] }) : /* @__PURE__ */ i(
+    "a",
+    {
+      href: a,
+      target: "_blank",
+      rel: "noreferrer",
+      className: o.link,
+      "aria-label": l,
+      children: [
+        /* @__PURE__ */ e(
+          "canvas",
+          {
+            "data-testid": "qr-code-canvas",
+            width: 164,
+            height: 164,
+            ref: t
+          }
+        ),
+        c && /* @__PURE__ */ e("div", { children: c })
+      ]
+    }
+  );
+}
+export {
+  q as default
+};

package/dist/components/Spinner/Spinner.d.ts

@@ -0,0 +1,6 @@
+interface Props {
+    size?: 'small' | 'large';
+    disabled?: boolean;
+}
+export default function Spinner({ size, disabled }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Spinner/Spinner.js

@@ -0,0 +1,33 @@
+import { jsxs as a, jsx as i } from "react/jsx-runtime";
+import '../../assets/Spinner.css';const s = "_spinner_18gtf_3", t = "_largeSpinner_18gtf_10 _spinner_18gtf_3", r = "_animated_18gtf_19", _ = "_disabled_18gtf_35", n = {
+  spinner: s,
+  largeSpinner: t,
+  animated: r,
+  disabled: _
+};
+function p({ size: e, disabled: d }) {
+  return /* @__PURE__ */ a(
+    "div",
+    {
+      className: `${e === "large" ? n.largeSpinner : n.spinner} ${d ? n.disabled : n.animated}`,
+      "data-testid": "spinner",
+      children: [
+        /* @__PURE__ */ i("div", {}),
+        /* @__PURE__ */ i("div", {}),
+        /* @__PURE__ */ i("div", {}),
+        /* @__PURE__ */ i("div", {}),
+        /* @__PURE__ */ i("div", {}),
+        /* @__PURE__ */ i("div", {}),
+        /* @__PURE__ */ i("div", {}),
+        /* @__PURE__ */ i("div", {}),
+        /* @__PURE__ */ i("div", {}),
+        /* @__PURE__ */ i("div", {}),
+        /* @__PURE__ */ i("div", {}),
+        /* @__PURE__ */ i("div", {})
+      ]
+    }
+  );
+}
+export {
+  p as default
+};

package/dist/components/Webcam/Webcam.d.ts

@@ -0,0 +1,15 @@
+interface Props {
+    interval?: number;
+    capture?: boolean;
+    disable?: boolean;
+    onCapture?: (image: HTMLCanvasElement) => void | Promise<void>;
+    onPreprocess?: (image: HTMLCanvasElement) => void | Promise<void>;
+    onPostprocess?: (image: HTMLCanvasElement) => void | Promise<void>;
+    onActivated?: (available: boolean) => void;
+    onFatal?: () => void;
+    direct?: boolean;
+    hidden?: boolean;
+    size: number;
+}
+export default function Webcam({ interval, capture, onCapture, disable, direct, hidden, onPreprocess, onPostprocess, onActivated, onFatal, size, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Webcam/Webcam.js

@@ -0,0 +1,397 @@
+import { jsx as s, jsxs as F, Fragment as q } from "react/jsx-runtime";
+import * as G from "react";
+import { useState as M, useRef as O, useEffect as y, useCallback as E } from "react";
+import { useTranslation as J } from "react-i18next";
+import { IconButton as V } from "@mui/material";
+import { c as Q } from "../../createSvgIcon-BfF8yuCp.js";
+import { WebcamClass as Y } from "./webcamClass.js";
+import { g as Z, u as z, s as P, c as W, a as ee, m as te } from "../../DefaultPropsProvider-C0Ib4Mye.js";
+import { g as ae, b as ne, P as a } from "../../createTheme-BIcG8YPQ.js";
+import { css as A, keyframes as H } from "@emotion/react";
+import '../../assets/Webcam.css';function re(e) {
+  return String(e).match(/[\d.\-+]*\s*(.*)/)[1] || "";
+}
+function ie(e) {
+  return parseFloat(e);
+}
+const oe = "_container_u6uf5_1", se = "_wrapContainer_u6uf5_5", ce = "_flipButton_u6uf5_10", N = {
+  container: oe,
+  wrapContainer: se,
+  flipButton: ce
+};
+function le(e) {
+  return ae("MuiSkeleton", e);
+}
+Z("MuiSkeleton", ["root", "text", "rectangular", "rounded", "circular", "pulse", "wave", "withChildren", "fitContent", "heightAuto"]);
+const ue = (e) => {
+  const {
+    classes: i,
+    variant: r,
+    animation: o,
+    hasChildren: u,
+    width: v,
+    height: f
+  } = e;
+  return ee({
+    root: ["root", r, o, u && "withChildren", u && !v && "fitContent", u && !f && "heightAuto"]
+  }, le, i);
+}, $ = H`
+  0% {
+    opacity: 1;
+  }
+
+  50% {
+    opacity: 0.4;
+  }
+
+  100% {
+    opacity: 1;
+  }
+`, j = H`
+  0% {
+    transform: translateX(-100%);
+  }
+
+  50% {
+    /* +0.5s of delay between each loop */
+    transform: translateX(100%);
+  }
+
+  100% {
+    transform: translateX(100%);
+  }
+`, fe = typeof $ != "string" ? A`
+        animation: ${$} 2s ease-in-out 0.5s infinite;
+      ` : null, pe = typeof j != "string" ? A`
+        &::after {
+          animation: ${j} 2s linear 0.5s infinite;
+        }
+      ` : null, de = P("span", {
+  name: "MuiSkeleton",
+  slot: "Root",
+  overridesResolver: (e, i) => {
+    const {
+      ownerState: r
+    } = e;
+    return [i.root, i[r.variant], r.animation !== !1 && i[r.animation], r.hasChildren && i.withChildren, r.hasChildren && !r.width && i.fitContent, r.hasChildren && !r.height && i.heightAuto];
+  }
+})(te(({
+  theme: e
+}) => {
+  const i = re(e.shape.borderRadius) || "px", r = ie(e.shape.borderRadius);
+  return {
+    display: "block",
+    // Create a "on paper" color with sufficient contrast retaining the color
+    backgroundColor: e.vars ? e.vars.palette.Skeleton.bg : ne(e.palette.text.primary, e.palette.mode === "light" ? 0.11 : 0.13),
+    height: "1.2em",
+    variants: [{
+      props: {
+        variant: "text"
+      },
+      style: {
+        marginTop: 0,
+        marginBottom: 0,
+        height: "auto",
+        transformOrigin: "0 55%",
+        transform: "scale(1, 0.60)",
+        borderRadius: `${r}${i}/${Math.round(r / 0.6 * 10) / 10}${i}`,
+        "&:empty:before": {
+          content: '"\\00a0"'
+        }
+      }
+    }, {
+      props: {
+        variant: "circular"
+      },
+      style: {
+        borderRadius: "50%"
+      }
+    }, {
+      props: {
+        variant: "rounded"
+      },
+      style: {
+        borderRadius: (e.vars || e).shape.borderRadius
+      }
+    }, {
+      props: ({
+        ownerState: o
+      }) => o.hasChildren,
+      style: {
+        "& > *": {
+          visibility: "hidden"
+        }
+      }
+    }, {
+      props: ({
+        ownerState: o
+      }) => o.hasChildren && !o.width,
+      style: {
+        maxWidth: "fit-content"
+      }
+    }, {
+      props: ({
+        ownerState: o
+      }) => o.hasChildren && !o.height,
+      style: {
+        height: "auto"
+      }
+    }, {
+      props: {
+        animation: "pulse"
+      },
+      style: fe || {
+        animation: `${$} 2s ease-in-out 0.5s infinite`
+      }
+    }, {
+      props: {
+        animation: "wave"
+      },
+      style: {
+        position: "relative",
+        overflow: "hidden",
+        /* Fix bug in Safari https://bugs.webkit.org/show_bug.cgi?id=68196 */
+        WebkitMaskImage: "-webkit-radial-gradient(white, black)",
+        "&::after": {
+          background: `linear-gradient(
+                90deg,
+                transparent,
+                ${(e.vars || e).palette.action.hover},
+                transparent
+              )`,
+          content: '""',
+          position: "absolute",
+          transform: "translateX(-100%)",
+          bottom: 0,
+          left: 0,
+          right: 0,
+          top: 0
+        }
+      }
+    }, {
+      props: {
+        animation: "wave"
+      },
+      style: pe || {
+        "&::after": {
+          animation: `${j} 2s linear 0.5s infinite`
+        }
+      }
+    }]
+  };
+})), K = /* @__PURE__ */ G.forwardRef(function(i, r) {
+  const o = z({
+    props: i,
+    name: "MuiSkeleton"
+  }), {
+    animation: u = "pulse",
+    className: v,
+    component: f = "span",
+    height: m,
+    style: p,
+    variant: w = "text",
+    width: l,
+    ...h
+  } = o, t = {
+    ...o,
+    animation: u,
+    component: f,
+    variant: w,
+    hasChildren: !!h.children
+  }, T = ue(t);
+  return /* @__PURE__ */ s(de, {
+    as: f,
+    ref: r,
+    className: W(T.root, v),
+    ownerState: t,
+    ...h,
+    style: {
+      width: l,
+      height: m,
+      ...p
+    }
+  });
+});
+process.env.NODE_ENV !== "production" && (K.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The animation.
+   * If `false` the animation effect is disabled.
+   * @default 'pulse'
+   */
+  animation: a.oneOf(["pulse", "wave", !1]),
+  /**
+   * Optional children to infer width and height from.
+   */
+  children: a.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: a.object,
+  /**
+   * @ignore
+   */
+  className: a.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: a.elementType,
+  /**
+   * Height of the skeleton.
+   * Useful when you don't want to adapt the skeleton to a text element but for instance a card.
+   */
+  height: a.oneOfType([a.number, a.string]),
+  /**
+   * @ignore
+   */
+  style: a.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: a.oneOfType([a.arrayOf(a.oneOfType([a.func, a.object, a.bool])), a.func, a.object]),
+  /**
+   * The type of content that will be rendered.
+   * @default 'text'
+   */
+  variant: a.oneOfType([a.oneOf(["circular", "rectangular", "rounded", "text"]), a.string]),
+  /**
+   * Width of the skeleton.
+   * Useful when the skeleton is inside an inline element with no width of its own.
+   */
+  width: a.oneOfType([a.number, a.string])
+});
+const X = Q([/* @__PURE__ */ s("path", {
+  d: "M16 7h-1l-1-1h-4L9 7H8c-1.1 0-2 .9-2 2v6c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V9c0-1.1-.9-2-2-2m-4 7c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2"
+}, "0"), /* @__PURE__ */ s("path", {
+  d: "m8.57.51 4.48 4.48V2.04c4.72.47 8.48 4.23 8.95 8.95h2C23.34 3.02 15.49-1.59 8.57.51m2.38 21.45c-4.72-.47-8.48-4.23-8.95-8.95H0c.66 7.97 8.51 12.58 15.43 10.48l-4.48-4.48z"
+}, "1")], "Cameraswitch");
+function Re({
+  interval: e,
+  capture: i,
+  onCapture: r,
+  disable: o,
+  direct: u,
+  hidden: v,
+  onPreprocess: f,
+  onPostprocess: m,
+  onActivated: p,
+  onFatal: w,
+  size: l
+}) {
+  const { t: h } = J(), [t, T] = M(null), b = O(null), C = O(-1), _ = O(0), d = O(), [k, L] = M(!1), [R, D] = M(!1);
+  y(() => {
+    d.current = async (n) => {
+      var c;
+      if (o) {
+        d.current && (C.current = window.requestAnimationFrame(d.current));
+        return;
+      }
+      if (t && t.canvas) {
+        t.update();
+        const x = e !== void 0 ? e : 1e3;
+        if (f && await f(t.canvas), i && r && n - _.current >= x) {
+          if (u && t.canvas)
+            await r(t.canvas);
+          else {
+            const g = document.createElement("canvas");
+            g.width = t.canvas.width, g.height = t.canvas.height;
+            const S = g.getContext("2d");
+            S || console.error("Failed to get context"), S == null || S.drawImage(t.canvas, 0, 0), await r(g);
+          }
+          _.current = n;
+        }
+        const I = (c = b.current) == null ? void 0 : c.getContext("2d");
+        I && (I.drawImage(t.canvas, 0, 0), m && b.current && await m(b.current));
+      }
+      d.current && (C.current = window.requestAnimationFrame(d.current));
+    }, C.current === -1 && (C.current = window.requestAnimationFrame(d.current));
+  }, [t, e, i, r, u, o, m, f]);
+  const B = E(
+    async (n) => {
+      var c;
+      if (await n.setup({ facingMode: R ? "user" : "environment" }), n.webcam && (n.webcam.playsInline = !0, n.webcam.muted = !0, n.webcam.onsuspend = () => n.play(), T(n)), (c = navigator.mediaDevices) != null && c.enumerateDevices)
+        try {
+          (await navigator.mediaDevices.enumerateDevices()).filter((g) => g.kind === "videoinput").length > 1 && (k || L(!0), n.flip = R);
+        } catch (x) {
+          console.error(x);
+        }
+      return p && p(!0), n;
+    },
+    [p, R, k]
+  );
+  y(() => {
+    i && (_.current = 0);
+  }, [i]), y(() => {
+    const n = new Y(l, l, !0);
+    return B(n).catch((c) => {
+      p && p(!1), console.error("No webcam", c), w && w();
+    }), () => {
+      var c;
+      (c = n.webcam) != null && c.srcObject && n.stop();
+    };
+  }, [R, p, B, w, l]), y(() => () => {
+    var n;
+    d.current = void 0, (n = t == null ? void 0 : t.webcam) != null && n.srcObject && t.stop();
+  }, [t]), y(() => {
+    t && (o ? t.pause() : t.play());
+  }, [t, o]);
+  const U = E(() => {
+    D((n) => !n);
+  }, [D]);
+  return v ? /* @__PURE__ */ s(q, { children: k && /* @__PURE__ */ s(
+    V,
+    {
+      size: "large",
+      color: "inherit",
+      onClick: U,
+      "aria-label": h("webcam.aria.flip"),
+      children: /* @__PURE__ */ s(X, { fontSize: "large" })
+    }
+  ) }) : /* @__PURE__ */ F(q, { children: [
+    !t && /* @__PURE__ */ s(
+      K,
+      {
+        variant: "rounded",
+        width: l,
+        height: l
+      }
+    ),
+    t && /* @__PURE__ */ F("div", { className: N.wrapContainer, children: [
+      k && /* @__PURE__ */ s(
+        V,
+        {
+          className: N.flipButton,
+          size: "large",
+          color: "inherit",
+          onClick: U,
+          "aria-label": h("webcam.aria.flip"),
+          children: /* @__PURE__ */ s(X, { fontSize: "large" })
+        }
+      ),
+      /* @__PURE__ */ s(
+        "div",
+        {
+          "data-testid": "webcam",
+          className: N.container,
+          role: "img",
+          "aria-label": h("webcam.aria.video"),
+          children: /* @__PURE__ */ s(
+            "canvas",
+            {
+              width: l,
+              height: l,
+              ref: b
+            }
+          )
+        }
+      )
+    ] })
+  ] });
+}
+export {
+  Re as default
+};

package/dist/components/Webcam/webcamClass.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+export declare class WebcamClass {
+    flip: boolean;
+    width: number;
+    height: number;
+    webcam?: HTMLVideoElement;
+    canvas?: HTMLCanvasElement;
+    constructor(width?: number, height?: number, flip?: boolean);
+    getWebcam(options?: MediaTrackConstraints): Promise<HTMLVideoElement>;
+    setup(options?: MediaTrackConstraints): Promise<void>;
+    play(): Promise<void> | undefined;
+    pause(): void;
+    stop(): void;
+    update(): void;
+    stopStreamedVideo(videoEl: HTMLVideoElement): void;
+    renderCameraToCanvas(): void;
+}

package/dist/components/Webcam/webcamClass.js

@@ -0,0 +1,76 @@
+var h = Object.defineProperty;
+var d = (t, e, a) => e in t ? h(t, e, { enumerable: !0, configurable: !0, writable: !0, value: a }) : t[e] = a;
+var s = (t, e, a) => d(t, typeof e != "symbol" ? e + "" : e, a);
+import { cropTo as m } from "../../util/canvas.js";
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const r = {
+  facingMode: "user",
+  frameRate: 24
+}, v = (t) => (t.facingMode = t.facingMode || r.facingMode, t.frameRate = t.frameRate || r.frameRate, t.aspectRatio = t.aspectRatio || r.aspectRatio, t);
+class u {
+  constructor(e = 400, a = 400, i = !1) {
+    s(this, "flip");
+    s(this, "width");
+    s(this, "height");
+    s(this, "webcam");
+    s(this, "canvas");
+    this.width = e, this.height = a, this.flip = i;
+  }
+  getWebcam(e = {}) {
+    if (!window.navigator.mediaDevices || !window.navigator.mediaDevices.getUserMedia)
+      return Promise.reject("Your browser does not support WebRTC. Please try another one.");
+    e.width = 640;
+    const a = v(e), i = document.createElement("video");
+    return window.navigator.mediaDevices.getUserMedia({ video: a }).then(
+      (c) => (i.srcObject = c, i.addEventListener("loadedmetadata", () => {
+        const { videoWidth: o, videoHeight: n } = i;
+        i.width = o, i.height = n;
+      }), i),
+      () => Promise.reject("Could not open your camera. You may have denied access.")
+    );
+  }
+  // setup or setupWebcam
+  async setup(e = {}) {
+    this.webcam || (this.webcam = await this.getWebcam(e), this.canvas || (this.canvas = document.createElement("canvas"), this.canvas.width = this.width, this.canvas.height = this.height));
+  }
+  play() {
+    var a;
+    return (a = this.webcam) == null ? void 0 : a.play();
+  }
+  pause() {
+    var e;
+    (e = this.webcam) == null || e.pause();
+  }
+  stop() {
+    this.webcam && this.stopStreamedVideo(this.webcam);
+  }
+  update() {
+    this.renderCameraToCanvas();
+  }
+  stopStreamedVideo(e) {
+    e.srcObject.getTracks().forEach((c) => {
+      c.stop();
+    }), e.srcObject = null;
+  }
+  renderCameraToCanvas() {
+    this.canvas && this.webcam && this.canvas.getContext("2d") && this.webcam.videoWidth !== 0 && m(this.webcam, this.width, this.flip, this.canvas);
+  }
+}
+export {
+  u as WebcamClass
+};