allaw-ui 0.1.71 → 1.0.0

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

@@ -0,0 +1,77 @@
+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);
+};
+// BaseFilter.stories.js
+import React from 'react';
+import "../../../styles/global.css";
+import BaseFilter from './Filter';
+export default {
+    title: 'Components/Atoms/Filters/Filter',
+    component: BaseFilter,
+};
+var Template = function (args) { return React.createElement(BaseFilter, __assign({}, args)); };
+export var Default = Template.bind({});
+Default.args = {
+    tooltipContent: 'This is a tooltip',
+    tooltipId: 'tooltip-1',
+    showIcon: true,
+    defaultSelectedValues: ['confirmed'],
+    filterData: [
+        { value: 'confirmed', name: 'Confirmed' },
+        { value: 'pending', name: 'Pending' },
+        { value: 'available', name: 'Available' },
+        { value: 'unavailable', name: 'Unavailable' },
+        { value: 'cancelled', name: 'Cancelled' },
+        { value: 'passed', name: 'Passed' },
+        { value: 'refused', name: 'Refused' },
+    ],
+    setFilters: function (values) { return console.log('Selected values:', values); },
+    multiselect: true,
+    iconName: 'fa fa-filter', // Replace with your actual icon class
+    children: 'Filter Button',
+    showNumIndic: true,
+    isStatusTag: true,
+};
+export var SingleSelect = Template.bind({});
+SingleSelect.args = {
+    tooltipContent: 'This is a tooltip',
+    tooltipId: 'tooltip-2',
+    showIcon: true,
+    defaultSelectedValues: ['confirmed'],
+    filterData: [
+        { value: 'confirmed', name: 'Confirmed' },
+        { value: 'pending', name: 'Pending' },
+        { value: 'available', name: 'Available' },
+    ],
+    setFilters: function (values) { return console.log('Selected values:', values); },
+    multiselect: false,
+    iconName: 'fa fa-filter', // Replace with your actual icon class
+    children: 'Single Select Filter Button',
+    showNumIndic: true,
+    isStatusTag: false,
+};
+export var WithoutIcon = Template.bind({});
+WithoutIcon.args = {
+    tooltipContent: 'This is a tooltip',
+    tooltipId: 'tooltip-3',
+    showIcon: false,
+    defaultSelectedValues: ['confirmed'],
+    filterData: [
+        { value: 'confirmed', name: 'Confirmed' },
+        { value: 'pending', name: 'Pending' },
+        { value: 'available', name: 'Available' },
+    ],
+    setFilters: function (values) { return console.log('Selected values:', values); },
+    multiselect: true,
+    children: 'Filter Button Without Icon',
+    showNumIndic: true,
+    isStatusTag: true,
+};

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/SingleFilter.stories.d.ts

@@ -0,0 +1,7 @@
+declare namespace _default {
+    export let title: string;
+    export { SingleFilter as component };
+}
+export default _default;
+export const Default: any;
+import SingleFilter from './SingleFilter';

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

@@ -0,0 +1,34 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import React from 'react';
+import SingleFilter from './SingleFilter'; // Ajustez le chemin selon votre structure de projet
+import './SingleFilter'; // Assurez-vous que le chemin est correct
+export default {
+    title: 'Components/Atoms/Filters/SingleFilter',
+    component: SingleFilter,
+};
+var Template = function (args) { return React.createElement(SingleFilter, __assign({}, args)); };
+export var Default = Template.bind({});
+Default.args = {
+    defaultSelectedValue: 'Option 1',
+    filterData: [
+        { value: 'option1', name: 'Option 1' },
+        { value: 'option2', name: 'Option 2' },
+        { value: 'option3', name: 'Option 3' },
+    ],
+    setFilter: function (selectedValue) { return console.log('Selected value:', selectedValue); },
+    children: 'Filter',
+    required: true,
+    showNumIndic: true,
+    showBackdrop: true,
+    isStatusTag: false,
+};

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,26 @@
+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;
+    rowChange?: (e: any) => void;
+    isRequired?: boolean;
+    validate?: RegExp | keyof typeof commonRegex;
+    onError?: (error: string) => void;
+    onChange?: (value: string) => void;
+    value?: string;
+    error?: string;
+    type?: string;
+    color?: "bleu-allaw" | "mid-grey" | "dark-grey" | "noir" | "pure-white" | "grey-venom" | "venom-grey-dark";
+    variant?: "bold" | "semiBold" | "medium";
+}
+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, rowChange = _a.rowChange, 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, _d = _a.type, type = _d === void 0 ? "text" : _d, propError = _a.error, _e = _a.color, color = _e === void 0 ? "noir" : _e, _f = _a.variant, variant = _f === void 0 ? "medium" : _f;
+    var _g = useState(false), isPasswordVisible = _g[0], setIsPasswordVisible = _g[1];
+    var _h = useState(propValue || ""), value = _h[0], setValue = _h[1];
+    var _j = useState(propError || ""), error = _j[0], setError = _j[1];
+    var _k = useState(false), isTouched = _k[0], setIsTouched = _k[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: variant, color: color, 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" : type, placeholder: placeholder, className: "Input-placeholder", value: value, onChange: function (e) { handleChange(e); rowChange && rowChange(e); }, 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/Input.stories.d.ts

@@ -0,0 +1,62 @@
+export const ActionsData: {};
+declare namespace _default {
+    export let title: string;
+    export { Input as component };
+    export let tags: string[];
+    export let excludeStories: RegExp;
+    export namespace args {
+        let endIcon: string;
+    }
+    export namespace argTypes {
+        export namespace style {
+            namespace control {
+                let type: string;
+                let options: string[];
+            }
+        }
+        export namespace endIcon_1 {
+            export namespace control_1 {
+                let type_1: string;
+                export { type_1 as type };
+            }
+            export { control_1 as control };
+        }
+        export { endIcon_1 as endIcon };
+        export namespace isRequired {
+            let control_2: string;
+            export { control_2 as control };
+        }
+        export namespace validate {
+            export namespace control_3 {
+                let type_2: string;
+                export { type_2 as type };
+            }
+            export { control_3 as control };
+        }
+        export namespace variant {
+            export namespace control_4 {
+                let type_3: string;
+                export { type_3 as type };
+                let options_1: string[];
+                export { options_1 as options };
+            }
+            export { control_4 as control };
+        }
+    }
+    export namespace parameters {
+        namespace backgrounds {
+            let _default: string;
+            export { _default as default };
+            export let values: {
+                name: string;
+                value: string;
+            }[];
+        }
+    }
+}
+export default _default;
+export const Default: any;
+export const Variation: any;
+export const Password: any;
+export const WithValidation: any;
+import Input from "./Input";

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

@@ -0,0 +1,101 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import React from "react";
+import { useForm, FormProvider } from "react-hook-form";
+import Input from "./Input";
+import "../../../styles/global.css";
+import "../../../styles/icons.css";
+export var ActionsData = {};
+export default {
+    title: "Components/Atoms/Inputs/Input",
+    component: Input,
+    tags: ["autodocs"],
+    excludeStories: /.*Data$/,
+    args: __assign(__assign({}, ActionsData), { endIcon: "allaw-icon-edit-2" }),
+    argTypes: {
+        style: {
+            control: {
+                type: "radio",
+                options: ["default", "variation", "password"],
+            },
+        },
+        endIcon: {
+            control: {
+                type: "text",
+            },
+        },
+        isRequired: {
+            control: "boolean",
+        },
+        validate: {
+            control: {
+                type: "text",
+            },
+        },
+        variant: {
+            control: {
+                type: "select",
+                options: ["bold", "semiBold", "medium"],
+            },
+        },
+    },
+    parameters: {
+        backgrounds: {
+            default: "light",
+            values: [
+                { name: "light", value: "#ffffff" },
+                { name: "grey", value: "#728ea7" },
+                { name: "figma", value: "#404040" },
+                { name: "dark", value: "#171e25" },
+            ],
+        },
+    },
+};
+var Template = function (args) {
+    var methods = useForm();
+    return (React.createElement(FormProvider, __assign({}, methods),
+        React.createElement(Input, __assign({}, args))));
+};
+export var Default = Template.bind({});
+Default.args = {
+    name: "defaultInput",
+    title: "Nommer le rendez-vous",
+    placeholder: "Entrez le motif du rendez-vous",
+    style: "default",
+    isRequired: false,
+    variant: "medium",
+};
+export var Variation = Template.bind({});
+Variation.args = {
+    name: "variationInput",
+    title: "Adresse e-mail",
+    placeholder: "Entrez le motif du rendez-vous",
+    style: "variation",
+    isRequired: true,
+};
+export var Password = Template.bind({});
+Password.args = {
+    name: "passwordInput",
+    title: "Mot de passe",
+    placeholder: "Entrez le nouveau mot de passe",
+    style: "password",
+    isRequired: false,
+};
+export var WithValidation = Template.bind({});
+WithValidation.args = {
+    name: "validationInput",
+    title: "Email",
+    placeholder: "Entrez votre email",
+    style: "default",
+    isRequired: true,
+    validate: "email",
+};

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

@@ -2,7 +2,7 @@
 
 .SearchBar {
   display: flex;
-  width: 339px;
+  width: 100%;
   height: 45px;
   padding: 0px 6px 0px 14px;
   align-items: center;

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/SearchBar.stories.d.ts

@@ -0,0 +1,54 @@
+export namespace ActionsData {
+    namespace onChange {
+        let action: string;
+    }
+}
+declare namespace _default {
+    export let title: string;
+    export { SearchBar as component };
+    export let tags: string[];
+    export let excludeStories: RegExp;
+    export namespace args {
+        let endIcon: string;
+    }
+    export namespace argTypes {
+        export namespace placeholder {
+            namespace control {
+                let type: string;
+            }
+        }
+        export namespace endIcon_1 {
+            export namespace control_1 {
+                let type_1: string;
+                export { type_1 as type };
+            }
+            export { control_1 as control };
+        }
+        export { endIcon_1 as endIcon };
+        export namespace value {
+            export namespace control_2 {
+                let type_2: string;
+                export { type_2 as type };
+            }
+            export { control_2 as control };
+        }
+        export namespace onChange_1 {
+            let action_1: string;
+            export { action_1 as action };
+        }
+        export { onChange_1 as onChange };
+    }
+    export namespace parameters {
+        namespace backgrounds {
+            let _default: string;
+            export { _default as default };
+            export let values: {
+                name: string;
+                value: string;
+            }[];
+        }
+    }
+}
+export default _default;
+export const Default: any;
+import SearchBar from "./SearchBar";