allaw-ui 1.0.1 → 1.0.2

package/dist/components/atoms/buttons/SecondaryButton.js

@@ -0,0 +1,117 @@
+"use client";
+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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { forwardRef, useImperativeHandle, useState, useEffect, } from "react";
+import "./SecondaryButton.css";
+import "../../../styles/global.css";
+var SecondaryButton = forwardRef(function (_a, ref) {
+    var startIcon = _a.startIcon, endIcon = _a.endIcon, startIconName = _a.startIconName, endIconName = _a.endIconName, label = _a.label, _b = _a.disabled, disabled = _b === void 0 ? false : _b, _c = _a.mode, mode = _c === void 0 ? "dark" : _c, onClick = _a.onClick, _d = _a.fullWidth, fullWidth = _d === void 0 ? false : _d, _e = _a.type, type = _e === void 0 ? "button" : _e, _f = _a.isLoading, isLoading = _f === void 0 ? false : _f, props = __rest(_a, ["startIcon", "endIcon", "startIconName", "endIconName", "label", "disabled", "mode", "onClick", "fullWidth", "type", "isLoading"]);
+    var buttonRef = React.useRef(null);
+    var _g = useState(false), internalIsLoading = _g[0], setInternalIsLoading = _g[1];
+    var _h = useState(""), loadingDots = _h[0], setLoadingDots = _h[1];
+    useImperativeHandle(ref, function () { return buttonRef.current; });
+    var isButtonLoading = isLoading || internalIsLoading;
+    useEffect(function () {
+        var interval = null;
+        if (isButtonLoading) {
+            interval = setInterval(function () {
+                setLoadingDots(function (prev) {
+                    if (prev.length >= 3)
+                        return "";
+                    return prev + ".";
+                });
+            }, 500);
+        }
+        return function () {
+            if (interval) {
+                clearInterval(interval);
+            }
+        };
+    }, [isButtonLoading]);
+    var handleClick = function (event) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (isButtonLoading) {
+                        event.preventDefault();
+                        return [2 /*return*/];
+                    }
+                    if (!onClick) return [3 /*break*/, 4];
+                    setInternalIsLoading(true);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, , 3, 4]);
+                    return [4 /*yield*/, onClick()];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    setInternalIsLoading(false);
+                    return [7 /*endfinally*/];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); };
+    return (React.createElement("button", __assign({ ref: buttonRef, className: "secondary-button ".concat(disabled ? "secondary-button-disabled" : "secondary-button-enabled", " secondary-button-").concat(mode, " ").concat(fullWidth ? "secondary-button-full-width" : "", " ").concat(isButtonLoading ? "secondary-button-loading" : ""), disabled: disabled, onClick: handleClick, type: type }, props),
+        startIcon && (React.createElement("span", { className: "secondary-button-icon ".concat(startIconName) })),
+        React.createElement("span", { className: "secondary-button-label" }, label),
+        isButtonLoading ? (React.createElement("span", { className: "secondary-button-loading-dots" }, loadingDots)) : (endIcon && React.createElement("span", { className: "secondary-button-icon ".concat(endIconName) }))));
+});
+SecondaryButton.displayName = "SecondaryButton";
+export default SecondaryButton;

package/dist/components/atoms/buttons/TabNavigation.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import "./TabNavigation.css";
+import "../../../styles/global.css";
+export interface TabNavigationProps {
+    tabs: {
+        label: string;
+        isActive: boolean;
+        hasNotification: boolean;
+    }[];
+    onTabClick: (index: number) => void;
+}
+declare const TabNavigation: React.FC<TabNavigationProps>;
+export default TabNavigation;

package/dist/components/atoms/buttons/TabNavigation.js

@@ -0,0 +1,10 @@
+import React from "react";
+import "./TabNavigation.css";
+import "../../../styles/global.css";
+var TabNavigation = function (_a) {
+    var tabs = _a.tabs, onTabClick = _a.onTabClick;
+    return (React.createElement("div", { className: "tab-navigation" }, tabs.map(function (tab, index) { return (React.createElement("div", { key: index, className: "tab-item ".concat(tab.isActive ? "active" : "inactive"), onClick: function () { return onTabClick(index); } },
+        React.createElement("span", { className: "tab-label" }, tab.label),
+        tab.hasNotification && React.createElement("span", { className: "tab-notification-dot" }))); })));
+};
+export default TabNavigation;

package/dist/components/atoms/buttons/TertiaryButton.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import "./TertiaryButton.css";
+import "../../../styles/global.css";
+export interface TertiaryButtonProps {
+    startIcon?: string;
+    label: string;
+    variant?: boolean;
+    onClick?: () => void;
+}
+declare const TertiaryButton: React.FC<TertiaryButtonProps>;
+export default TertiaryButton;

package/dist/components/atoms/buttons/TertiaryButton.js

@@ -0,0 +1,10 @@
+import React from "react";
+import "./TertiaryButton.css";
+import "../../../styles/global.css";
+var TertiaryButton = function (_a) {
+    var startIcon = _a.startIcon, label = _a.label, _b = _a.variant, variant = _b === void 0 ? false : _b, onClick = _a.onClick;
+    return (React.createElement("button", { type: "button", className: "tertiary-button ".concat(variant ? "tertiary-button-variant" : "tertiary-button-default"), onClick: onClick },
+        startIcon && React.createElement("span", { className: "tertiary-button-icon ".concat(startIcon) }),
+        React.createElement("span", { className: "tertiary-button-label" }, label)));
+};
+export default TertiaryButton;

package/dist/components/atoms/buttons/index.d.ts

@@ -0,0 +1,22 @@
+export { default as FavoriteToggle } from "./FavoriteToggle";
+export { default as FilterButtonPrimary } from "./FilterButtonPrimary";
+export { default as FilterButton } from "./FilterButton";
+export { default as GhostButton } from "./GhostButton";
+export { default as IconButton } from "./IconButton";
+export { default as PendingDocuments } from "./PendingDocuments";
+export { default as PrimaryButton } from "./PrimaryButton";
+export { default as SecondaryButton } from "./SecondaryButton";
+export { default as TabNavigation } from "./TabNavigation";
+export { default as TertiaryButton } from "./TertiaryButton";
+export { default as OAuthProviderButton } from "./OAuthProviderButton";
+export type { FavoriteToggleProps } from "./FavoriteToggle";
+export type { FilterButtonProps } from "./FilterButton";
+export type { GhostButtonProps } from "./GhostButton";
+export type { IconButtonProps } from "./IconButton";
+export type { PendingDocumentsProps } from "./PendingDocuments";
+export type { PrimaryButtonProps } from "./PrimaryButton";
+export type { SecondaryButtonProps } from "./SecondaryButton";
+export type { TabNavigationProps } from "./TabNavigation";
+export type { TertiaryButtonProps } from "./TertiaryButton";
+export type { OAuthProviderButtonProps } from "./OAuthProviderButton";
+export type { FilterButtonPrimaryProps } from "./FilterButtonPrimary";

package/dist/components/atoms/buttons/index.js

@@ -0,0 +1,11 @@
+export { default as FavoriteToggle } from "./FavoriteToggle";
+export { default as FilterButtonPrimary } from "./FilterButtonPrimary";
+export { default as FilterButton } from "./FilterButton";
+export { default as GhostButton } from "./GhostButton";
+export { default as IconButton } from "./IconButton";
+export { default as PendingDocuments } from "./PendingDocuments";
+export { default as PrimaryButton } from "./PrimaryButton";
+export { default as SecondaryButton } from "./SecondaryButton";
+export { default as TabNavigation } from "./TabNavigation";
+export { default as TertiaryButton } from "./TertiaryButton";
+export { default as OAuthProviderButton } from "./OAuthProviderButton";

package/dist/components/atoms/checkboxes/Checkbox.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import "./Checkbox.css";
+import "../../../styles/global.css";
+export interface CheckboxProps {
+    id?: string;
+    checked?: boolean;
+    onChange?: (checked: boolean) => void;
+    color?: string;
+    size?: "default" | "small";
+    style?: "default" | "light";
+    markType?: "cross" | "check";
+}
+declare const Checkbox: React.FC<CheckboxProps>;
+export default Checkbox;

package/dist/components/atoms/checkboxes/Checkbox.js

@@ -0,0 +1,19 @@
+import React, { useState } from "react";
+import "./Checkbox.css";
+import "../../../styles/global.css";
+var Checkbox = function (_a) {
+    var id = _a.id, _b = _a.checked, checked = _b === void 0 ? false : _b, onChange = _a.onChange, _c = _a.color, color = _c === void 0 ? "noir" : _c, _d = _a.size, size = _d === void 0 ? "default" : _d, _e = _a.style, style = _e === void 0 ? "default" : _e, _f = _a.markType, markType = _f === void 0 ? "cross" : _f;
+    var _g = useState(checked), isChecked = _g[0], setIsChecked = _g[1];
+    var handleClick = function (e) {
+        e.preventDefault();
+        e.stopPropagation();
+        var newChecked = !isChecked;
+        setIsChecked(newChecked);
+        if (onChange) {
+            onChange(newChecked);
+        }
+    };
+    var checkboxColor = style === "light" ? "light" : color;
+    return (React.createElement("button", { id: id, className: "checkbox ".concat(isChecked ? "checkbox-pressed" : "checkbox-default", " ").concat("checkbox-".concat(checkboxColor), " ").concat(size === "small" ? "checkbox-small" : "", " ").concat(style === "light" ? "checkbox-light" : ""), onClick: handleClick }, isChecked && (React.createElement("span", { className: "checkbox-icon ".concat(markType === "cross" ? "allaw-icon-close" : "allaw-icon-check", " ").concat("checkbox-icon-".concat(checkboxColor), " ").concat(style === "light" ? "checkbox-icon-light" : "") }))));
+};
+export default Checkbox;

package/dist/components/atoms/checkboxes/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Checkbox } from "./Checkbox";
+export type { CheckboxProps } from "./Checkbox";

package/dist/components/atoms/checkboxes/index.js

@@ -0,0 +1 @@
+export { default as Checkbox } from "./Checkbox";

package/dist/components/atoms/filter/Filter.d.ts

@@ -0,0 +1,17 @@
+import "./Basefiler.css";
+import React from "react";
+export type FilterProps = {
+    defaultSelectedValue?: string;
+    filterData: {
+        value: string;
+        name: string;
+    }[];
+    setFilter: (selectedValue: string) => void;
+    children?: React.ReactNode;
+    required?: boolean;
+    showNumIndic?: boolean;
+    showBackdrop?: boolean;
+    isStatusTag?: boolean;
+};
+declare const BaseFilter: ({ showNumIndic, required, defaultSelectedValue, filterData, setFilter, showBackdrop, children, ...props }: FilterProps) => React.JSX.Element;
+export default BaseFilter;

package/dist/components/atoms/filter/Filter.js

@@ -0,0 +1,70 @@
+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);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import "./Basefiler.css";
+import { FilterButtonPrimary, PrimaryButton } from "../buttons";
+import { TinyInfo } from "../typography";
+import React, { useState } from "react";
+var BaseFilter = function (_a) {
+    var _b = _a.showNumIndic, showNumIndic = _b === void 0 ? false : _b, _c = _a.required, required = _c === void 0 ? true : _c, defaultSelectedValue = _a.defaultSelectedValue, filterData = _a.filterData, setFilter = _a.setFilter, _d = _a.showBackdrop, showBackdrop = _d === void 0 ? false : _d, children = _a.children, props = __rest(_a, ["showNumIndic", "required", "defaultSelectedValue", "filterData", "setFilter", "showBackdrop", "children"]);
+    var _e = useState(false), isOpen = _e[0], setIsOpen = _e[1];
+    var _f = useState(defaultSelectedValue || ""), selectedValue = _f[0], setSelectedValue = _f[1];
+    var handleClose = function () {
+        setFilter(selectedValue);
+        setIsOpen(false);
+    };
+    var handleButtonTap = function () {
+        isOpen ? handleClose() : setIsOpen(true);
+    };
+    var Item = function (_a) {
+        var name = _a.name, value = _a.value;
+        return (React.createElement("button", { className: "item", onClick: function () { setSelectedValue(value); handleClose(); } },
+            React.createElement("div", { className: "round" },
+                React.createElement("div", { className: selectedValue === value ? "selected" : "notSelected" })),
+            React.createElement("span", null, name)));
+    };
+    var SmallItem = function (_a) {
+        var name = _a.name, value = _a.value;
+        return (React.createElement("button", { className: "smallItem", onClick: function () { setSelectedValue(value); } },
+            React.createElement("div", { className: "round" },
+                React.createElement("div", { className: selectedValue === value ? "selected" : "notSelected" })),
+            React.createElement("span", null, name)));
+    };
+    return (React.createElement(React.Fragment, null,
+        React.createElement("div", __assign({ className: "baseFilter" }, props),
+            React.createElement(FilterButtonPrimary, { onClick: handleButtonTap, zIndex: "2000" },
+                children,
+                React.createElement("p", { style: { color: "#25BEEB", fontWeight: "600" } }, showNumIndic && "(".concat(selectedValue.length, ")"))),
+            isOpen && (React.createElement("div", { className: "options" }, filterData && filterData.length > 0 &&
+                filterData.map(function (item, idx) { return (React.createElement(Item, { name: item.name, value: item.value, key: idx })); }))),
+            React.createElement("div", { className: "optionsSmall", style: { bottom: isOpen ? "0" : "-100%" } },
+                React.createElement("div", { className: "row" },
+                    React.createElement("div", { style: { minWidth: "20px" } }),
+                    React.createElement(TinyInfo, { text: children, variant: "bold14", color: "noir" }),
+                    React.createElement("button", { className: "closeButton", onClick: handleClose },
+                        React.createElement("i", { className: "allaw-icon-close" }))),
+                React.createElement("div", { className: "choices" }, filterData && filterData.length > 0 &&
+                    filterData.map(function (item, idx) { return (React.createElement(SmallItem, { name: item.name, value: item.value, key: idx })); })),
+                React.createElement(PrimaryButton, { label: "Voir les r\u00E9sultats", onClick: handleClose }))),
+        isOpen && (React.createElement("div", { className: "backdrop", onClick: handleClose }))));
+};
+export default BaseFilter;

package/dist/components/atoms/filter/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Filter } from "./Filter";
+export type { FilterProps } from "./Filter";

package/dist/components/atoms/filter/index.js

@@ -0,0 +1 @@
+export { default as Filter } from "./Filter";

package/dist/components/atoms/filters/SingleFilter.d.ts

@@ -0,0 +1,17 @@
+import "./SingleFilter.css";
+import React from "react";
+export type SingleFilterProps = {
+    defaultSelectedValue?: string;
+    filterData: {
+        value: string;
+        name: string;
+    }[];
+    setFilter: (selectedValue: string) => void;
+    children?: React.ReactNode;
+    required?: boolean;
+    showNumIndic?: boolean;
+    showBackdrop?: boolean;
+    isStatusTag?: boolean;
+};
+declare const SingleFilter: ({ showNumIndic, required, defaultSelectedValue, filterData, setFilter, showBackdrop, children, ...props }: SingleFilterProps) => React.JSX.Element;
+export default SingleFilter;

package/dist/components/atoms/filters/SingleFilter.js

@@ -0,0 +1,81 @@
+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);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import "./SingleFilter.css";
+import { FilterButtonPrimary, PrimaryButton } from "../buttons";
+import { TinyInfo } from "../typography";
+import React, { useState, useEffect } from "react";
+var SingleFilter = function (_a) {
+    var _b = _a.showNumIndic, showNumIndic = _b === void 0 ? false : _b, _c = _a.required, required = _c === void 0 ? true : _c, defaultSelectedValue = _a.defaultSelectedValue, filterData = _a.filterData, setFilter = _a.setFilter, _d = _a.showBackdrop, showBackdrop = _d === void 0 ? false : _d, children = _a.children, props = __rest(_a, ["showNumIndic", "required", "defaultSelectedValue", "filterData", "setFilter", "showBackdrop", "children"]);
+    var _e = useState(false), isOpen = _e[0], setIsOpen = _e[1];
+    var _f = useState(defaultSelectedValue || ""), selectedValue = _f[0], setSelectedValue = _f[1];
+    useEffect(function () {
+        if (selectedValue) {
+            setFilter(selectedValue);
+        }
+    }, [selectedValue, setFilter]);
+    var handleClose = function () {
+        setIsOpen(false);
+    };
+    var handleButtonTap = function () {
+        setIsOpen(!isOpen);
+    };
+    var Item = function (_a) {
+        var name = _a.name, value = _a.value;
+        return (React.createElement("button", { className: "item", onClick: function () {
+                setSelectedValue(value);
+                handleClose();
+            } },
+            React.createElement("div", { className: "round" },
+                React.createElement("div", { className: selectedValue === value ? "selected" : "notSelected" })),
+            React.createElement("span", null, name)));
+    };
+    var SmallItem = function (_a) {
+        var name = _a.name, value = _a.value;
+        return (React.createElement("button", { className: "smallItem", onClick: function () {
+                setSelectedValue(value);
+            } },
+            React.createElement("div", { className: "round" },
+                React.createElement("div", { className: selectedValue === value ? "selected" : "notSelected" })),
+            React.createElement("span", null, name)));
+    };
+    return (React.createElement(React.Fragment, null,
+        React.createElement("div", __assign({ className: "baseFilter" }, props),
+            React.createElement(FilterButtonPrimary, { onClick: handleButtonTap },
+                children,
+                React.createElement("p", { style: { color: "#25BEEB", fontWeight: "600" } }, showNumIndic && "(".concat(selectedValue.length, ")"))),
+            isOpen && (React.createElement("div", { className: "options" }, filterData &&
+                filterData.length > 0 &&
+                filterData.map(function (item, idx) { return (React.createElement(Item, { name: item.name, value: item.value, key: idx })); }))),
+            React.createElement("div", { className: "optionsSmall", style: { bottom: isOpen ? "0" : "-100%" } },
+                React.createElement("div", { className: "row" },
+                    React.createElement("div", { style: { minWidth: "20px" } }),
+                    React.createElement(TinyInfo, { text: children, variant: "bold14", color: "noir" }),
+                    React.createElement("button", { className: "closeButton", onClick: handleClose },
+                        React.createElement("i", { className: "allaw-icon-close" }))),
+                React.createElement("div", { className: "choices" }, filterData &&
+                    filterData.length > 0 &&
+                    filterData.map(function (item, idx) { return (React.createElement(SmallItem, { name: item.name, value: item.value, key: idx })); })),
+                React.createElement(PrimaryButton, { label: "Voir les r\u00E9sultats", onClick: handleClose }))),
+        isOpen && React.createElement("div", { className: "backdrop", onClick: handleClose })));
+};
+export default SingleFilter;

package/dist/components/atoms/filters/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SingleFilter } from "./SingleFilter";
+export type { SingleFilterProps } from "./SingleFilter";

package/dist/components/atoms/filters/index.js

@@ -0,0 +1 @@
+export { default as SingleFilter } from "./SingleFilter";

package/dist/components/atoms/inputs/Input.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+import "./Input.css";
+import "../../../styles/global.css";
+import "../../../styles/icons.css";
+import { commonRegex } from "../../../utils/regex";
+export interface InputProps {
+    title: string;
+    style?: "default" | "variation" | "password";
+    placeholder: string;
+    endIcon?: string;
+    isRequired?: boolean;
+    validate?: RegExp | keyof typeof commonRegex;
+    onError?: (error: string) => void;
+    onChange?: (value: string) => void;
+    value?: string;
+    error?: string;
+}
+export interface InputRef {
+    validate: () => boolean;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<InputRef>>;
+export default Input;

package/dist/components/atoms/inputs/Input.js

@@ -0,0 +1,86 @@
+import React, { useState, useEffect, useCallback, forwardRef, useImperativeHandle, useRef, } from "react";
+import "./Input.css";
+import "../../../styles/global.css";
+import "../../../styles/icons.css";
+import { commonRegex } from "../../../utils/regex";
+import TinyInfo from "../typography/TinyInfo";
+import Paragraph from "../typography/Paragraph";
+var Input = forwardRef(function (_a, ref) {
+    var title = _a.title, _b = _a.style, style = _b === void 0 ? "default" : _b, placeholder = _a.placeholder, endIcon = _a.endIcon, _c = _a.isRequired, isRequired = _c === void 0 ? false : _c, validate = _a.validate, onError = _a.onError, onChange = _a.onChange, propValue = _a.value, propError = _a.error;
+    var _d = useState(false), isPasswordVisible = _d[0], setIsPasswordVisible = _d[1];
+    var _e = useState(propValue || ""), value = _e[0], setValue = _e[1];
+    var _f = useState(propError || ""), error = _f[0], setError = _f[1];
+    var _g = useState(false), isTouched = _g[0], setIsTouched = _g[1];
+    var inputRef = useRef(null);
+    useEffect(function () {
+        setValue(propValue || "");
+    }, [propValue]);
+    useEffect(function () {
+        setError(propError || "");
+    }, [propError]);
+    var validateInput = useCallback(function () {
+        var _a;
+        // console.log(`Input ${title}: Validating input`);
+        var currentValue = ((_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.value) || value;
+        // console.log(`Input ${title}: Current value: "${currentValue}"`);
+        var errorMessage = "";
+        if (isRequired && currentValue.trim() === "") {
+            errorMessage = "Ce champ est requis";
+        }
+        else if (validate && currentValue) {
+            var regex = typeof validate === "string" ? commonRegex[validate] : validate;
+            // console.log(`Input ${title}: Regex used: ${regex}`);
+            if (!regex.test(currentValue)) {
+                errorMessage = "Veuillez vérifier votre saisie";
+            }
+        }
+        setError(errorMessage);
+        setIsTouched(true);
+        // console.log(
+        //   `Input ${title}: Validation result - ${errorMessage ? "invalid" : "valid"}`
+        // );
+        onError === null || onError === void 0 ? void 0 : onError(errorMessage);
+        return !errorMessage;
+    }, [isRequired, value, validate, onError, title]);
+    useImperativeHandle(ref, function () { return ({
+        validate: validateInput,
+    }); });
+    var handleChange = function (e) {
+        var newValue = e.target.value;
+        // console.log(`Input ${title}: Value changed to "${newValue}"`);
+        setValue(newValue);
+        onChange === null || onChange === void 0 ? void 0 : onChange(newValue);
+        if (isTouched) {
+            validateInput();
+        }
+    };
+    var handleBlur = function () {
+        // console.log(`Input ${title}: Blur event triggered`);
+        setIsTouched(true);
+        validateInput();
+    };
+    var renderEndIcon = function () {
+        if (style === "variation" && endIcon) {
+            return (React.createElement("button", { className: "Input-icon-button" },
+                React.createElement("i", { className: endIcon })));
+        }
+        if (style === "password") {
+            return (React.createElement("button", { className: "Input-button", onClick: function () { return setIsPasswordVisible(!isPasswordVisible); } }, isPasswordVisible ? "CACHER" : "AFFICHER"));
+        }
+        return null;
+    };
+    return (React.createElement("div", { className: "Input Input-".concat(style) },
+        React.createElement("div", { className: "Input-title-container" },
+            React.createElement(Paragraph, { variant: "semiBold", color: "noir", text: title }),
+            isRequired && title && (React.createElement("span", { className: "Input-required" },
+                "\u00A0",
+                "*"))),
+        React.createElement("div", { className: "Input-container" },
+            React.createElement("div", { className: "Input-input ".concat(style === "password" ? "Input-password-input" : "") },
+                React.createElement("input", { ref: inputRef, type: style === "password" && !isPasswordVisible ? "password" : "text", placeholder: placeholder, className: "Input-placeholder", value: value, onChange: handleChange, onBlur: handleBlur })),
+            renderEndIcon(),
+            error && isTouched && (React.createElement("div", { className: "error-message" },
+                React.createElement(TinyInfo, { variant: "medium12", color: "actions-error", text: error }))))));
+});
+Input.displayName = "Input";
+export default Input;

package/dist/components/atoms/inputs/SearchBar.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import "./SearchBar.css";
+import "../../../styles/global.css";
+import "../../../styles/icons.css";
+export interface SearchBarProps {
+    placeholder?: string;
+    endIcon?: string;
+    value?: string;
+    onChange?: (value: string) => void;
+}
+declare const SearchBar: React.FC<SearchBarProps>;
+export default SearchBar;

package/dist/components/atoms/inputs/SearchBar.js

@@ -0,0 +1,20 @@
+import React, { useState } from "react";
+import "./SearchBar.css";
+import "../../../styles/global.css";
+import "../../../styles/icons.css";
+var SearchBar = function (_a) {
+    var _b = _a.placeholder, placeholder = _b === void 0 ? "Faites une recherche" : _b, _c = _a.endIcon, endIcon = _c === void 0 ? "allaw-icon-search" : _c, _d = _a.value, controlledValue = _d === void 0 ? "" : _d, onChange = _a.onChange;
+    var _e = useState(controlledValue), value = _e[0], setValue = _e[1];
+    var handleChange = function (event) {
+        var newValue = event.target.value;
+        setValue(newValue);
+        if (onChange) {
+            onChange(newValue);
+        }
+    };
+    return (React.createElement("div", { className: "SearchBar" },
+        React.createElement("input", { type: "text", placeholder: placeholder, className: "SearchBar-placeholder", value: controlledValue || value, onChange: handleChange }),
+        React.createElement("button", { className: "SearchBar-icon-button" },
+            React.createElement("i", { className: endIcon }))));
+};
+export default SearchBar;

package/dist/components/atoms/inputs/TextArea.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+import "./TextArea.css";
+import "../../../styles/global.css";
+import { commonRegex } from "../../../utils/regex";
+export interface TextAreaProps {
+    title: string;
+    style?: "default" | "variation";
+    placeholder: string;
+    isRequired?: boolean;
+    validate?: RegExp | keyof typeof commonRegex;
+    onError?: (error: string) => void;
+    onChange?: (e: React.ChangeEvent<HTMLTextAreaElement>) => void;
+    value?: string;
+    error?: string;
+    maxHeight?: number;
+}
+export interface TextAreaRef {
+    validate: () => boolean;
+}
+declare const TextArea: React.ForwardRefExoticComponent<TextAreaProps & React.RefAttributes<TextAreaRef>>;
+export default TextArea;