@arthurzakharov/ui-kit 1.0.3 → 1.0.5

package/dist/components/control/components/text/text.test.js

@@ -0,0 +1,146 @@
+import { jsx as s } from "react/jsx-runtime";
+import { f as v, e, a as b, b as h, d as y, r as i } from "../../../../react.esm-CZ9PjZjp.js";
+import { useState as f, useEffect as m } from "react";
+import { d as p, f as c } from "../../../../index-DZTmNCEj.js";
+import { c as S } from "../../../../input.component-Ju0oHzs9.js";
+import { d as w, i as r, g as u } from "../../../../vi.2VT5v0um-CyasTEXm.js";
+const g = {
+  title: "Components/Control/Text",
+  component: p.Text,
+  tags: ["autodocs"],
+  args: {
+    label: "Text label",
+    state: "idle",
+    type: "text",
+    id: "text-input",
+    value: "Some value",
+    disabled: !1,
+    onChange: v(),
+    onFocus: v(),
+    onBlur: v()
+  },
+  argTypes: {
+    state: {
+      control: "select",
+      options: ["idle", "error", "success", "warning"]
+    },
+    type: {
+      control: "text"
+    },
+    disabled: {
+      control: "boolean"
+    }
+  },
+  render: (a) => {
+    const [d, o] = f(a.value);
+    return m(() => {
+      o(a.value);
+    }, [a.value]), /* @__PURE__ */ s("div", { style: { maxWidth: 300 }, children: /* @__PURE__ */ s(
+      p.Text,
+      {
+        ...a,
+        value: d,
+        onChange: (n, t, l) => {
+          o(n), a.onChange?.(n, t, l);
+        }
+      }
+    ) });
+  }
+}, x = {
+  args: {
+    state: void 0,
+    type: void 0,
+    onAutofill: void 0,
+    onAutofillCancel: void 0,
+    disabled: void 0,
+    onFocus: void 0,
+    onBlur: void 0
+  }
+}, T = {
+  args: {
+    value: ""
+  }
+}, C = {
+  args: {
+    disabled: !1
+  }
+}, H = {
+  args: {
+    disabled: !0
+  }
+}, I = {
+  args: {
+    state: "idle"
+  }
+}, V = {
+  args: {
+    state: "error"
+  }
+}, A = {
+  args: {
+    state: "success"
+  }
+}, M = {
+  args: {
+    value: ""
+  },
+  play: async ({ args: a, canvas: d, step: o, userEvent: n }) => {
+    const t = d.getByTestId("input"), l = d.getByTestId("text-label");
+    await o("Initial state should be idle", async () => {
+      await e(t).toHaveValue(a.value), await e(l).toHaveClass(c.TextLabelIdle);
+    }), await o("Focusing input should activate label", async () => {
+      await n.click(t), await e(l).toHaveClass(c.TextLabelActive), await e(t).toHaveFocus();
+    }), await o("Blurring empty input should return to idle", async () => {
+      await n.tab(), await e(l).toHaveClass(c.TextLabelIdle), await e(t).not.toHaveFocus();
+    }), await o("Autofill start should activate label", async () => {
+      b.animationStart(t, { animationName: S["autofill-start"] }), await h(() => e(l).toHaveClass(c.TextLabelActive));
+    }), await o("Autofill cancel should deactivate label", async () => {
+      b.animationStart(t, { animationName: S["autofill-cancel"] }), await h(() => e(l).toHaveClass(c.TextLabelIdle));
+    }), await o("Typing should keep label active", async () => {
+      await n.click(t), await n.type(t, "Hello World"), await e(t).toHaveValue("Hello World"), await e(l).toHaveClass(c.TextLabelActive);
+    }), await o("Blurring with value should keep label active", async () => {
+      await n.tab(), await e(l).toHaveClass(c.TextLabelActive);
+    }), await o("Autofill cancel with value should keep label active", async () => {
+      b.animationStart(t, { animationName: S["autofill-cancel"] }), await h(() => e(l).toHaveClass(c.TextLabelActive));
+    });
+  }
+}, $ = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DefaultValues: x,
+  Disabled: H,
+  Enabled: C,
+  Interactive: M,
+  StateError: V,
+  StateIdle: I,
+  StateSuccess: A,
+  WithoutValue: T,
+  default: g
+}, Symbol.toStringTag, { value: "Module" })), { DefaultValues: D, WithoutValue: L, Enabled: E, Disabled: W, StateIdle: B, StateError: F, StateSuccess: k, Interactive: _ } = y($);
+w("Text Snapshot", () => {
+  r("DefaultValues", async () => {
+    const { container: a } = i(/* @__PURE__ */ s(D, {}));
+    u(a).toMatchSnapshot();
+  }), r("WithoutValue", async () => {
+    const { container: a } = i(/* @__PURE__ */ s(L, {}));
+    u(a).toMatchSnapshot();
+  }), r("Enabled", async () => {
+    const { container: a } = i(/* @__PURE__ */ s(E, {}));
+    u(a).toMatchSnapshot();
+  }), r("Disabled", async () => {
+    const { container: a } = i(/* @__PURE__ */ s(W, {}));
+    u(a).toMatchSnapshot();
+  }), r("StateIdle", async () => {
+    const { container: a } = i(/* @__PURE__ */ s(B, {}));
+    u(a).toMatchSnapshot();
+  }), r("StateError", async () => {
+    const { container: a } = i(/* @__PURE__ */ s(F, {}));
+    u(a).toMatchSnapshot();
+  }), r("StateSuccess", async () => {
+    const { container: a } = i(/* @__PURE__ */ s(k, {}));
+    u(a).toMatchSnapshot();
+  }), r("Interactive", async () => {
+    const { container: a } = i(/* @__PURE__ */ s(_, {}));
+    u(a).toMatchSnapshot();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"text.test.js","sources":["../../../../../src/components/control/components/text/text.stories.tsx","../../../../../src/components/control/components/text/text.test.tsx"],"sourcesContent":["import type { Meta, StoryObj } from '@storybook/react-vite';\nimport { useEffect, useState } from 'react';\nimport { expect, fn, fireEvent, waitFor } from 'storybook/test';\nimport { Control } from '@/components/control';\nimport cn from '@/components/control/components/text/text.module.css';\nimport inputCn from '@/components/control/components/input/input.module.css';\n\nconst meta = {\n  title: 'Components/Control/Text',\n  component: Control.Text,\n  tags: ['autodocs'],\n  args: {\n    label: 'Text label',\n    state: 'idle',\n    type: 'text',\n    id: 'text-input',\n    value: 'Some value',\n    disabled: false,\n    onChange: fn(),\n    onFocus: fn(),\n    onBlur: fn(),\n  },\n  argTypes: {\n    state: {\n      control: 'select',\n      options: ['idle', 'error', 'success', 'warning'],\n    },\n    type: {\n      control: 'text',\n    },\n    disabled: {\n      control: 'boolean',\n    },\n  },\n  render: (args) => {\n    const [value, setValue] = useState<string>(args.value);\n\n    useEffect(() => {\n      setValue(args.value);\n    }, [args.value]);\n\n    return (\n      <div style={{ maxWidth: 300 }}>\n        <Control.Text\n          {...args}\n          value={value}\n          onChange={(value, id, source) => {\n            setValue(value);\n            args.onChange?.(value, id, source);\n          }}\n        />\n      </div>\n    );\n  },\n} satisfies Meta<typeof Control.Text>;\n\nexport default meta;\ntype Story = StoryObj<typeof meta>;\n\nexport const DefaultValues: Story = {\n  args: {\n    state: undefined,\n    type: undefined,\n    onAutofill: undefined,\n    onAutofillCancel: undefined,\n    disabled: undefined,\n    onFocus: undefined,\n    onBlur: undefined,\n  },\n};\n\nexport const WithoutValue: Story = {\n  args: {\n    value: '',\n  },\n};\n\nexport const Enabled: Story = {\n  args: {\n    disabled: false,\n  },\n};\n\nexport const Disabled: Story = {\n  args: {\n    disabled: true,\n  },\n};\n\nexport const StateIdle: Story = {\n  args: {\n    state: 'idle',\n  },\n};\n\nexport const StateError: Story = {\n  args: {\n    state: 'error',\n  },\n};\n\nexport const StateSuccess: Story = {\n  args: {\n    state: 'success',\n  },\n};\n\nexport const Interactive: Story = {\n  args: {\n    value: '',\n  },\n  play: async ({ args, canvas, step, userEvent }) => {\n    const input = canvas.getByTestId('input');\n    const label = canvas.getByTestId('text-label');\n\n    await step('Initial state should be idle', async () => {\n      await expect(input).toHaveValue(args.value);\n      await expect(label).toHaveClass(cn.TextLabelIdle);\n    });\n\n    await step('Focusing input should activate label', async () => {\n      await userEvent.click(input);\n      await expect(label).toHaveClass(cn.TextLabelActive);\n      await expect(input).toHaveFocus();\n    });\n\n    await step('Blurring empty input should return to idle', async () => {\n      await userEvent.tab();\n      await expect(label).toHaveClass(cn.TextLabelIdle);\n      await expect(input).not.toHaveFocus();\n    });\n\n    await step('Autofill start should activate label', async () => {\n      fireEvent.animationStart(input, { animationName: inputCn['autofill-start'] });\n      await waitFor(() => expect(label).toHaveClass(cn.TextLabelActive));\n    });\n\n    await step('Autofill cancel should deactivate label', async () => {\n      fireEvent.animationStart(input, { animationName: inputCn['autofill-cancel'] });\n      await waitFor(() => expect(label).toHaveClass(cn.TextLabelIdle));\n    });\n\n    await step('Typing should keep label active', async () => {\n      await userEvent.click(input);\n      await userEvent.type(input, 'Hello World');\n      await expect(input).toHaveValue('Hello World');\n      await expect(label).toHaveClass(cn.TextLabelActive);\n    });\n\n    await step('Blurring with value should keep label active', async () => {\n      await userEvent.tab();\n      await expect(label).toHaveClass(cn.TextLabelActive);\n    });\n\n    await step('Autofill cancel with value should keep label active', async () => {\n      fireEvent.animationStart(input, { animationName: inputCn['autofill-cancel'] });\n      await waitFor(() => expect(label).toHaveClass(cn.TextLabelActive));\n    });\n  },\n};\n","import { composeStories } from '@storybook/react-vite';\nimport { render } from '@testing-library/react';\nimport { describe, expect, it } from 'vitest';\nimport * as stories from '@/components/control/components/text/text.stories';\n\nconst { DefaultValues, WithoutValue, Enabled, Disabled, StateIdle, StateError, StateSuccess, Interactive } =\n  composeStories(stories);\n\ndescribe('Text Snapshot', () => {\n  it('DefaultValues', async () => {\n    const { container } = render(<DefaultValues />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('WithoutValue', async () => {\n    const { container } = render(<WithoutValue />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('Enabled', async () => {\n    const { container } = render(<Enabled />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('Disabled', async () => {\n    const { container } = render(<Disabled />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('StateIdle', async () => {\n    const { container } = render(<StateIdle />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('StateError', async () => {\n    const { container } = render(<StateError />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('StateSuccess', async () => {\n    const { container } = render(<StateSuccess />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('Interactive', async () => {\n    const { container } = render(<Interactive />);\n    expect(container).toMatchSnapshot();\n  });\n});\n"],"names":["meta","Control","fn","args","value","setValue","useState","useEffect","jsx","id","source","DefaultValues","WithoutValue","Enabled","Disabled","StateIdle","StateError","StateSuccess","Interactive","canvas","step","userEvent","input","label","expect","cn","fireEvent","inputCn","waitFor","composeStories","stories","describe","it","container","render"],"mappings":"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"}

package/dist/components/control/components/text/text.types.d.ts

@@ -0,0 +1,6 @@
+import { InputProps } from '../input/input.types';
+import { State } from '../../types';
+export interface TextProps extends InputProps {
+    label: string;
+    state?: State;
+}

package/dist/components/control/components/text/text.types.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGV4dC50eXBlcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/components/control/components/textarea/index.d.ts

@@ -0,0 +1 @@
+export { Textarea } from './textarea.component';

package/dist/components/control/components/textarea/index.js

@@ -0,0 +1,5 @@
+import { T as r } from "../../../../index-DZTmNCEj.js";
+export {
+  r as Textarea
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOyJ9

package/dist/components/control/components/textarea/textarea.component.d.ts

@@ -0,0 +1,2 @@
+import { TextareaProps } from './textarea.types';
+export declare const Textarea: (props: TextareaProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/control/components/textarea/textarea.component.js

@@ -0,0 +1,7 @@
+import "react/jsx-runtime";
+import "usehooks-ts";
+import { T as e } from "../../../../index-DZTmNCEj.js";
+export {
+  e as Textarea
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGV4dGFyZWEuY29tcG9uZW50LmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OyJ9

package/dist/components/control/components/textarea/textarea.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/control/components/textarea/textarea.test.js

@@ -0,0 +1,148 @@
+import { jsx as o } from "react/jsx-runtime";
+import { f as c, w as m, e as n, u as r, a as h, b as v, d as b, r as s } from "../../../../react.esm-CZ9PjZjp.js";
+import { useState as y, useEffect as g } from "react";
+import { d as S, e as f } from "../../../../index-DZTmNCEj.js";
+import { d as p, i as l, g as i } from "../../../../vi.2VT5v0um-CyasTEXm.js";
+const x = {
+  title: "Components/Control/Textarea",
+  component: S.Textarea,
+  tags: ["autodocs"],
+  args: {
+    state: "idle",
+    placeholder: "Textarea placeholder",
+    rows: 5,
+    onAutofill: c(),
+    onAutofillCancel: c(),
+    id: "textarea",
+    value: "Some value",
+    disabled: !1,
+    onChange: c(),
+    onFocus: c(),
+    onBlur: c()
+  },
+  argTypes: {
+    state: {
+      control: "select",
+      options: ["idle", "error", "success"]
+    },
+    rows: {
+      control: "number"
+    },
+    disabled: {
+      control: "boolean"
+    }
+  },
+  render: (a) => {
+    const [u, e] = y(a.value);
+    return g(() => {
+      e(a.value);
+    }, [a.value]), /* @__PURE__ */ o("div", { style: { maxWidth: 300 }, children: /* @__PURE__ */ o(
+      S.Textarea,
+      {
+        ...a,
+        value: u,
+        onChange: (d, t, w) => {
+          e(d), a.onChange?.(d, t, w);
+        }
+      }
+    ) });
+  }
+}, A = {
+  args: {
+    state: void 0,
+    placeholder: void 0,
+    rows: void 0,
+    onAutofill: void 0,
+    onAutofillCancel: void 0,
+    disabled: void 0,
+    onFocus: void 0,
+    onBlur: void 0
+  }
+}, E = {
+  args: {
+    value: ""
+  }
+}, V = {
+  args: {
+    disabled: !1
+  }
+}, C = {
+  args: {
+    disabled: !0
+  }
+}, H = {
+  args: {
+    state: "idle"
+  }
+}, I = {
+  args: {
+    state: "error"
+  }
+}, M = {
+  args: {
+    state: "success"
+  }
+}, T = {
+  args: {
+    value: ""
+  },
+  play: async ({ args: a, canvasElement: u, step: e }) => {
+    const t = m(u).getByTestId("textarea");
+    await e("Initial state should be idle", async () => {
+      await n(t).toHaveValue(a.value);
+    }), await e("Focusing textarea", async () => {
+      await r.click(t), await n(t).toHaveFocus();
+    }), await e("Blurring empty textarea", async () => {
+      await r.tab(), await n(t).not.toHaveFocus();
+    }), await e("Autofill start should trigger onAutofill", async () => {
+      h.animationStart(t, { animationName: f["autofill-start"] }), await v(() => n(t).toHaveAttribute("data-is-idle", "false"));
+    }), await e("Autofill cancel should trigger onAutofillCancel", async () => {
+      h.animationStart(t, { animationName: f["autofill-cancel"] }), await v(() => n(t).toHaveAttribute("data-is-idle", "true"));
+    }), await e("Typing should update value", async () => {
+      await r.click(t), await r.type(t, "Hello World"), await n(t).toHaveValue("Hello World");
+    }), await e("Blurring textarea with value", async () => {
+      await r.tab(), await n(t).not.toHaveFocus();
+    }), await e("Autofill cancel with value should trigger onAutofillCancel", async () => {
+      h.animationStart(t, { animationName: f["autofill-cancel"] }), await v(() => n(t).toHaveAttribute("data-is-idle", "false"));
+    });
+  }
+}, D = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DefaultValues: A,
+  Disabled: C,
+  Enabled: V,
+  Interactive: T,
+  StateError: I,
+  StateIdle: H,
+  StateSuccess: M,
+  WithoutValue: E,
+  default: x
+}, Symbol.toStringTag, { value: "Module" })), { DefaultValues: $, WithoutValue: F, Enabled: W, Disabled: B, StateIdle: _, StateError: j, StateSuccess: N, Interactive: k } = b(D);
+p("Textarea Snapshot", () => {
+  l("DefaultValues", async () => {
+    const { container: a } = s(/* @__PURE__ */ o($, {}));
+    i(a).toMatchSnapshot();
+  }), l("WithoutValue", async () => {
+    const { container: a } = s(/* @__PURE__ */ o(F, {}));
+    i(a).toMatchSnapshot();
+  }), l("Enabled", async () => {
+    const { container: a } = s(/* @__PURE__ */ o(W, {}));
+    i(a).toMatchSnapshot();
+  }), l("Disabled", async () => {
+    const { container: a } = s(/* @__PURE__ */ o(B, {}));
+    i(a).toMatchSnapshot();
+  }), l("StateIdle", async () => {
+    const { container: a } = s(/* @__PURE__ */ o(_, {}));
+    i(a).toMatchSnapshot();
+  }), l("StateError", async () => {
+    const { container: a } = s(/* @__PURE__ */ o(j, {}));
+    i(a).toMatchSnapshot();
+  }), l("StateSuccess", async () => {
+    const { container: a } = s(/* @__PURE__ */ o(N, {}));
+    i(a).toMatchSnapshot();
+  }), l("Interactive", async () => {
+    const { container: a } = s(/* @__PURE__ */ o(k, {}));
+    i(a).toMatchSnapshot();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"textarea.test.js","sources":["../../../../../src/components/control/components/textarea/textarea.stories.tsx","../../../../../src/components/control/components/textarea/textarea.test.tsx"],"sourcesContent":["import type { Meta, StoryObj } from '@storybook/react-vite';\nimport { useEffect, useState } from 'react';\nimport { expect, fn, fireEvent, userEvent, waitFor, within } from 'storybook/test';\nimport { Control } from '@/components/control';\nimport cn from '@/components/control/components/textarea/textarea.module.css';\n\nconst meta = {\n  title: 'Components/Control/Textarea',\n  component: Control.Textarea,\n  tags: ['autodocs'],\n  args: {\n    state: 'idle',\n    placeholder: 'Textarea placeholder',\n    rows: 5,\n    onAutofill: fn(),\n    onAutofillCancel: fn(),\n    id: 'textarea',\n    value: 'Some value',\n    disabled: false,\n    onChange: fn(),\n    onFocus: fn(),\n    onBlur: fn(),\n  },\n  argTypes: {\n    state: {\n      control: 'select',\n      options: ['idle', 'error', 'success'],\n    },\n    rows: {\n      control: 'number',\n    },\n    disabled: {\n      control: 'boolean',\n    },\n  },\n  render: (args) => {\n    const [value, setValue] = useState<string>(args.value);\n\n    useEffect(() => {\n      setValue(args.value);\n    }, [args.value]);\n\n    return (\n      <div style={{ maxWidth: 300 }}>\n        <Control.Textarea\n          {...args}\n          value={value}\n          onChange={(value, id, source) => {\n            setValue(value);\n            args.onChange?.(value, id, source);\n          }}\n        />\n      </div>\n    );\n  },\n} satisfies Meta<typeof Control.Textarea>;\n\nexport default meta;\ntype Story = StoryObj<typeof meta>;\n\nexport const DefaultValues: Story = {\n  args: {\n    state: undefined,\n    placeholder: undefined,\n    rows: undefined,\n    onAutofill: undefined,\n    onAutofillCancel: undefined,\n    disabled: undefined,\n    onFocus: undefined,\n    onBlur: undefined,\n  },\n};\n\nexport const WithoutValue: Story = {\n  args: {\n    value: '',\n  },\n};\n\nexport const Enabled: Story = {\n  args: {\n    disabled: false,\n  },\n};\n\nexport const Disabled: Story = {\n  args: {\n    disabled: true,\n  },\n};\n\nexport const StateIdle: Story = {\n  args: {\n    state: 'idle',\n  },\n};\n\nexport const StateError: Story = {\n  args: {\n    state: 'error',\n  },\n};\n\nexport const StateSuccess: Story = {\n  args: {\n    state: 'success',\n  },\n};\n\nexport const Interactive: Story = {\n  args: {\n    value: '',\n  },\n  play: async ({ args, canvasElement, step }) => {\n    const canvas = within(canvasElement);\n    const textarea = canvas.getByTestId('textarea');\n\n    await step('Initial state should be idle', async () => {\n      await expect(textarea).toHaveValue(args.value);\n    });\n\n    await step('Focusing textarea', async () => {\n      await userEvent.click(textarea);\n      await expect(textarea).toHaveFocus();\n    });\n\n    await step('Blurring empty textarea', async () => {\n      await userEvent.tab();\n      await expect(textarea).not.toHaveFocus();\n    });\n\n    await step('Autofill start should trigger onAutofill', async () => {\n      fireEvent.animationStart(textarea, { animationName: cn['autofill-start'] });\n      await waitFor(() => expect(textarea).toHaveAttribute('data-is-idle', 'false'));\n    });\n\n    await step('Autofill cancel should trigger onAutofillCancel', async () => {\n      fireEvent.animationStart(textarea, { animationName: cn['autofill-cancel'] });\n      await waitFor(() => expect(textarea).toHaveAttribute('data-is-idle', 'true'));\n    });\n\n    await step('Typing should update value', async () => {\n      await userEvent.click(textarea);\n      await userEvent.type(textarea, 'Hello World');\n      await expect(textarea).toHaveValue('Hello World');\n    });\n\n    await step('Blurring textarea with value', async () => {\n      await userEvent.tab();\n      await expect(textarea).not.toHaveFocus();\n    });\n\n    await step('Autofill cancel with value should trigger onAutofillCancel', async () => {\n      fireEvent.animationStart(textarea, { animationName: cn['autofill-cancel'] });\n      await waitFor(() => expect(textarea).toHaveAttribute('data-is-idle', 'false'));\n    });\n  },\n};\n","import { composeStories } from '@storybook/react-vite';\nimport { render } from '@testing-library/react';\nimport { describe, expect, it } from 'vitest';\nimport * as stories from '@/components/control/components/textarea/textarea.stories';\n\nconst { DefaultValues, WithoutValue, Enabled, Disabled, StateIdle, StateError, StateSuccess, Interactive } =\n  composeStories(stories);\n\ndescribe('Textarea Snapshot', () => {\n  it('DefaultValues', async () => {\n    const { container } = render(<DefaultValues />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('WithoutValue', async () => {\n    const { container } = render(<WithoutValue />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('Enabled', async () => {\n    const { container } = render(<Enabled />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('Disabled', async () => {\n    const { container } = render(<Disabled />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('StateIdle', async () => {\n    const { container } = render(<StateIdle />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('StateError', async () => {\n    const { container } = render(<StateError />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('StateSuccess', async () => {\n    const { container } = render(<StateSuccess />);\n    expect(container).toMatchSnapshot();\n  });\n\n  it('Interactive', async () => {\n    const { container } = render(<Interactive />);\n    expect(container).toMatchSnapshot();\n  });\n});\n"],"names":["meta","Control","fn","args","value","setValue","useState","useEffect","jsx","id","source","DefaultValues","WithoutValue","Enabled","Disabled","StateIdle","StateError","StateSuccess","Interactive","canvasElement","step","textarea","within","expect","userEvent","fireEvent","cn","waitFor","composeStories","stories","describe","it","container","render"],"mappings":"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"}

package/dist/components/control/components/textarea/textarea.types.d.ts

@@ -0,0 +1,8 @@
+import { Interactive, State } from '../../types';
+export interface TextareaProps extends Interactive<string> {
+    state?: State;
+    placeholder?: string;
+    rows?: number;
+    onAutofill?: (id: string) => void;
+    onAutofillCancel?: (id: string) => void;
+}

package/dist/components/control/components/textarea/textarea.types.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGV4dGFyZWEudHlwZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/components/control/hooks/index.d.ts

@@ -0,0 +1 @@
+export { useChoice } from './useChoice';

package/dist/components/control/hooks/index.js

@@ -0,0 +1,5 @@
+import { useChoice as r } from "./useChoice/useChoice.hook.js";
+export {
+  r as useChoice
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOyJ9

package/dist/components/control/hooks/useChoice/index.d.ts

@@ -0,0 +1 @@
+export { useChoice } from './useChoice.hook';

package/dist/components/control/hooks/useChoice/index.js

@@ -0,0 +1,5 @@
+import { useChoice as r } from "./useChoice.hook.js";
+export {
+  r as useChoice
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOyJ9

package/dist/components/control/hooks/useChoice/useChoice.hook.d.ts

@@ -0,0 +1,5 @@
+import { ChoiceType, ChoiceValue, InputChangeSource, Interactive } from '../../types';
+export declare const useChoice: (value: ChoiceValue, id: string, cb: Interactive<ChoiceValue>["onChange"]) => {
+    type: ChoiceType;
+    onChoiceChange: (newValue: string, source?: InputChangeSource) => void;
+};

package/dist/components/control/hooks/useChoice/useChoice.hook.js

@@ -0,0 +1,10 @@
+const s = (o, i, e) => ({
+  type: typeof o == "string" ? "radio" : "checkbox",
+  onChoiceChange: (t, r) => {
+    e(typeof o == "string" ? t : o.includes(t) ? o.filter((n) => n !== t).filter(Boolean) : [...o, t].filter(Boolean), i, r);
+  }
+});
+export {
+  s as useChoice
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlQ2hvaWNlLmhvb2suanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9jb21wb25lbnRzL2NvbnRyb2wvaG9va3MvdXNlQ2hvaWNlL3VzZUNob2ljZS5ob29rLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgQ2hvaWNlVHlwZSwgQ2hvaWNlVmFsdWUsIElucHV0Q2hhbmdlU291cmNlLCBJbnRlcmFjdGl2ZSB9IGZyb20gJ0AvY29tcG9uZW50cy9jb250cm9sL3R5cGVzJztcblxuZXhwb3J0IGNvbnN0IHVzZUNob2ljZSA9ICh2YWx1ZTogQ2hvaWNlVmFsdWUsIGlkOiBzdHJpbmcsIGNiOiBJbnRlcmFjdGl2ZTxDaG9pY2VWYWx1ZT5bJ29uQ2hhbmdlJ10pID0+IHtcbiAgY29uc3QgdHlwZTogQ2hvaWNlVHlwZSA9IHR5cGVvZiB2YWx1ZSA9PT0gJ3N0cmluZycgPyAncmFkaW8nIDogJ2NoZWNrYm94JztcblxuICByZXR1cm4ge1xuICAgIHR5cGUsXG4gICAgb25DaG9pY2VDaGFuZ2U6IChuZXdWYWx1ZTogc3RyaW5nLCBzb3VyY2U/OiBJbnB1dENoYW5nZVNvdXJjZSkgPT4ge1xuICAgICAgaWYgKHR5cGVvZiB2YWx1ZSA9PT0gJ3N0cmluZycpIHtcbiAgICAgICAgY2IobmV3VmFsdWUsIGlkLCBzb3VyY2UpO1xuICAgICAgfSBlbHNlIHtcbiAgICAgICAgY2IoXG4gICAgICAgICAgdmFsdWUuaW5jbHVkZXMobmV3VmFsdWUpXG4gICAgICAgICAgICA/IHZhbHVlLmZpbHRlcigodikgPT4gdiAhPT0gbmV3VmFsdWUpLmZpbHRlcihCb29sZWFuKVxuICAgICAgICAgICAgOiBbLi4udmFsdWUsIG5ld1ZhbHVlXS5maWx0ZXIoQm9vbGVhbiksXG4gICAgICAgICAgaWQsXG4gICAgICAgICAgc291cmNlLFxuICAgICAgICApO1xuICAgICAgfVxuICAgIH0sXG4gIH07XG59O1xuIl0sIm5hbWVzIjpbInVzZUNob2ljZSIsInZhbHVlIiwiaWQiLCJjYiIsIm5ld1ZhbHVlIiwic291cmNlIiwidiJdLCJtYXBwaW5ncyI6IkFBRU8sTUFBTUEsSUFBWSxDQUFDQyxHQUFvQkMsR0FBWUMsT0FHakQ7QUFBQSxFQUNMLE1BSHVCLE9BQU9GLEtBQVUsV0FBVyxVQUFVO0FBQUEsRUFJN0QsZ0JBQWdCLENBQUNHLEdBQWtCQyxNQUErQjtBQUNoRSxJQUNFRixFQURFLE9BQU9GLEtBQVUsV0FDaEJHLElBR0RILEVBQU0sU0FBU0csQ0FBUSxJQUNuQkgsRUFBTSxPQUFPLENBQUNLLE1BQU1BLE1BQU1GLENBQVEsRUFBRSxPQUFPLE9BQU8sSUFDbEQsQ0FBQyxHQUFHSCxHQUFPRyxDQUFRLEVBQUUsT0FBTyxPQUFPLEdBTDVCRixHQUFJRyxDQUFNO0FBQUEsRUFVM0I7QUFBQTsifQ==

package/dist/components/control/hooks/useChoice/useChoice.hook.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/control/hooks/useChoice/useChoice.hook.test.js

@@ -0,0 +1,35 @@
+import { useChoice as n } from "./useChoice.hook.js";
+import { d as a, i, v as c, g as s } from "../../../../vi.2VT5v0um-CyasTEXm.js";
+a("useChoice", () => {
+  const t = "test-id";
+  a("Radio", () => {
+    i("should return radio type when value is string", () => {
+      const o = c.fn(), { type: e } = n("option1", t, o);
+      s(e).toBe("radio");
+    }), i("should call callback with new value, with source specified", () => {
+      const o = c.fn(), { onChoiceChange: e } = n("option1", t, o);
+      e("option2", "mouse"), s(o).toHaveBeenCalledWith("option2", t, "mouse");
+    }), i("should call callback with new value, without source specified", () => {
+      const o = c.fn(), { onChoiceChange: e } = n("option1", t, o);
+      e("option2"), s(o).toHaveBeenCalledWith("option2", t, void 0);
+    });
+  }), a("Checkbox", () => {
+    i("should return checkbox type when value is array of strings", () => {
+      const o = c.fn(), { type: e } = n(["option1"], t, o);
+      s(e).toBe("checkbox");
+    }), i("should add value when not present", () => {
+      const o = c.fn(), { onChoiceChange: e } = n(["option1"], t, o);
+      e("option2", "keyboard"), s(o).toHaveBeenCalledWith(["option1", "option2"], t, "keyboard");
+    }), i("should remove value when present", () => {
+      const o = c.fn(), { onChoiceChange: e } = n(["option1", "option2"], t, o);
+      e("option1", "keyboard"), s(o).toHaveBeenCalledWith(["option2"], t, "keyboard");
+    }), i("should filter out empty values", () => {
+      const o = c.fn(), { onChoiceChange: e } = n(["option1"], t, o);
+      e("", "mouse"), s(o).toHaveBeenCalledWith(["option1"], t, "mouse");
+    }), i("should call callback with new value, without source specified", () => {
+      const o = c.fn(), { onChoiceChange: e } = n(["option1"], t, o);
+      e("option2"), s(o).toHaveBeenCalledWith(["option1", "option2"], t, void 0);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/components/control/index.d.ts

@@ -0,0 +1,17 @@
+export declare const Control: {
+    Box: import('react').ForwardRefExoticComponent<import('./components/box/box.types').BoxProps & import('react').RefAttributes<HTMLDivElement>>;
+    Button: (props: import('./components/button/button.types').ButtonProps) => import("react/jsx-runtime").JSX.Element;
+    CardImage: (props: import('./components/card-image/card-image.types').CardImageProps) => import("react/jsx-runtime").JSX.Element;
+    CardText: (props: import('./components/card-text/card-text.types').CardTextProps) => import("react/jsx-runtime").JSX.Element;
+    Checkbox: (props: import('./components/checkbox/checkbox.types').CheckboxProps) => import("react/jsx-runtime").JSX.Element;
+    Choice: (props: import('./components/choice/choice.types').ChoiceProps) => import("react/jsx-runtime").JSX.Element;
+    Dropdown: (props: import('./components/dropdown/dropdown.types').DropdownProps) => import("react/jsx-runtime").JSX.Element;
+    HiddenInput: (props: import('./components/hidden-input/hidden-input.types').HiddenInputProps) => import("react/jsx-runtime").JSX.Element;
+    Input: ({ id, value, disabled, type, onAutofill, onAutofillCancel, onChange, onFocus, onBlur, }: import('./components/input/input.types').InputProps) => import("react/jsx-runtime").JSX.Element;
+    Label: (props: import('./components/label/label.types').LabelProps) => import("react/jsx-runtime").JSX.Element;
+    Radio: (props: import('./components/radio/radio.types').RadioProps) => import("react/jsx-runtime").JSX.Element;
+    RadioLabel: <T extends import('./types').ChoiceValue>(props: import('./components/radio-label/radio-label.types').RadioLabelProps<T>) => import("react/jsx-runtime").JSX.Element;
+    RadioText: (props: import('./components/radio-text/radio-text.types').RadioTextProps) => import("react/jsx-runtime").JSX.Element;
+    Text: (props: import('./components/text/text.types').TextProps) => import("react/jsx-runtime").JSX.Element;
+    Textarea: (props: import('./components/textarea/textarea.types').TextareaProps) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/components/control/index.js

@@ -0,0 +1,13 @@
+import "./components/box/box.component.js";
+import "./components/button/button.component.js";
+import { d as l } from "../../index-DZTmNCEj.js";
+import "./components/choice/choice.component.js";
+import "./components/hidden-input/hidden-input.component.js";
+import "../../input.component-Ju0oHzs9.js";
+import "./components/label/label.component.js";
+import "./components/radio-label/radio-label.component.js";
+import "./components/radio-text/radio-text.component.js";
+export {
+  l as Control
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7In0=

package/dist/components/control/types.d.ts

@@ -0,0 +1,35 @@
+export type InputChangeSource = 'mouse' | 'keyboard';
+export interface Interactive<V> {
+    id: string;
+    value: V;
+    disabled?: boolean;
+    onChange: (value: V, id: string, source?: InputChangeSource) => void;
+    onFocus?: (id: string) => void;
+    onBlur?: (id: string) => void;
+}
+export type RadioChoice = {
+    label: string;
+    value: string;
+    icon?: string;
+};
+export type ChoiceType = 'radio' | 'checkbox';
+export type ChoiceValue = string | string[];
+export type State = 'idle' | 'error' | 'success';
+export type QuestionPath = string[];
+export type QuestionChoice = {
+    value: string;
+    label: string;
+    icon?: string;
+    /**
+     * - string[] - array of question keys, that defines future path;
+     * - string - valid url that would be used for redirect;
+     */
+    path?: QuestionPath | string;
+    info?: string;
+    isPreselected?: boolean;
+    isDefault?: boolean;
+};
+export type Size = {
+    width: number;
+    height: number;
+};

package/dist/components/control/types.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/components/control/utils/index.d.ts

@@ -0,0 +1 @@
+export { getChoiceId, containsHtml, clickHasNode } from './utils';

package/dist/components/control/utils/index.js

@@ -0,0 +1,7 @@
+import { clickHasNode as e, containsHtml as t, getChoiceId as i } from "./utils.js";
+export {
+  e as clickHasNode,
+  t as containsHtml,
+  i as getChoiceId
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOyJ9

package/dist/components/control/utils/utils.d.ts

@@ -0,0 +1,4 @@
+import { RefObject } from 'react';
+export declare const getChoiceId: (id: string, value: string, index: number) => string;
+export declare const containsHtml: (str?: string) => boolean;
+export declare const clickHasNode: (event: MouseEvent | TouchEvent | FocusEvent, element: RefObject<HTMLElement>) => boolean;

package/dist/components/control/utils/utils.js

@@ -0,0 +1,7 @@
+const c = (t, n, r) => [t, r, n.replace(/\s+/g, "-")].join("-"), e = (t) => /<([a-z][a-z0-9]*)\b[^>]*>(.*?)<\/\1>|<([a-z][a-z0-9]*)\b[^>]*\/?>/i.test(t || ""), o = (t, n) => !!(n.current && n.current.contains(t.target));
+export {
+  o as clickHasNode,
+  e as containsHtml,
+  c as getChoiceId
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb21wb25lbnRzL2NvbnRyb2wvdXRpbHMvdXRpbHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBSZWZPYmplY3QgfSBmcm9tICdyZWFjdCc7XG5cbmV4cG9ydCBjb25zdCBnZXRDaG9pY2VJZCA9IChpZDogc3RyaW5nLCB2YWx1ZTogc3RyaW5nLCBpbmRleDogbnVtYmVyKSA9PiB7XG4gIHJldHVybiBbaWQsIGluZGV4LCB2YWx1ZS5yZXBsYWNlKC9cXHMrL2csICctJyldLmpvaW4oJy0nKTtcbn07XG5cbmV4cG9ydCBjb25zdCBjb250YWluc0h0bWwgPSAoc3RyPzogc3RyaW5nKTogYm9vbGVhbiA9PiB7XG4gIHJldHVybiAvPChbYS16XVthLXowLTldKilcXGJbXj5dKj4oLio/KTxcXC9cXDE+fDwoW2Etel1bYS16MC05XSopXFxiW14+XSpcXC8/Pi9pLnRlc3Qoc3RyIHx8ICcnKTtcbn07XG5cbmV4cG9ydCBjb25zdCBjbGlja0hhc05vZGUgPSAoZXZlbnQ6IE1vdXNlRXZlbnQgfCBUb3VjaEV2ZW50IHwgRm9jdXNFdmVudCwgZWxlbWVudDogUmVmT2JqZWN0PEhUTUxFbGVtZW50Pik6IGJvb2xlYW4gPT4ge1xuICByZXR1cm4gQm9vbGVhbihlbGVtZW50LmN1cnJlbnQgJiYgZWxlbWVudC5jdXJyZW50LmNvbnRhaW5zKGV2ZW50LnRhcmdldCBhcyBOb2RlKSk7XG59O1xuIl0sIm5hbWVzIjpbImdldENob2ljZUlkIiwiaWQiLCJ2YWx1ZSIsImluZGV4IiwiY29udGFpbnNIdG1sIiwic3RyIiwiY2xpY2tIYXNOb2RlIiwiZXZlbnQiLCJlbGVtZW50Il0sIm1hcHBpbmdzIjoiQUFFTyxNQUFNQSxJQUFjLENBQUNDLEdBQVlDLEdBQWVDLE1BQzlDLENBQUNGLEdBQUlFLEdBQU9ELEVBQU0sUUFBUSxRQUFRLEdBQUcsQ0FBQyxFQUFFLEtBQUssR0FBRyxHQUc1Q0UsSUFBZSxDQUFDQyxNQUNwQixxRUFBcUUsS0FBS0EsS0FBTyxFQUFFLEdBRy9FQyxJQUFlLENBQUNDLEdBQTZDQyxNQUNqRSxHQUFRQSxFQUFRLFdBQVdBLEVBQVEsUUFBUSxTQUFTRCxFQUFNLE1BQWM7In0=

package/dist/components/control/utils/utils.test.d.ts

@@ -0,0 +1 @@
+export {};