@opexa/portal-components 0.0.2 → 0.0.3

package/dist/ui/Tabs/Tabs.d.ts

@@ -0,0 +1,187 @@
+import { Tabs } from '@ark-ui/react';
+export declare const Root: import("react").ComponentType<import("@ark-ui/react").Assign<Tabs.RootProps & import("react").RefAttributes<HTMLDivElement>, import("tailwind-variants").VariantProps<import("tailwind-variants").TVReturnType<{
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, undefined, {
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, import("tailwind-variants").TVReturnType<{
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, undefined, unknown, unknown, undefined>>>>>;
+export declare const Content: import("react").ComponentType<import("@ark-ui/react").Assign<Tabs.ContentProps & import("react").RefAttributes<HTMLDivElement>, import("tailwind-variants").VariantProps<import("tailwind-variants").TVReturnType<{
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, undefined, {
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, import("tailwind-variants").TVReturnType<{
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, undefined, unknown, unknown, undefined>>>>>;
+export declare const Indicator: import("react").ComponentType<import("@ark-ui/react").Assign<Tabs.IndicatorProps & import("react").RefAttributes<HTMLDivElement>, import("tailwind-variants").VariantProps<import("tailwind-variants").TVReturnType<{
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, undefined, {
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, import("tailwind-variants").TVReturnType<{
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, undefined, unknown, unknown, undefined>>>>>;
+export declare const List: import("react").ComponentType<import("@ark-ui/react").Assign<Tabs.ListProps & import("react").RefAttributes<HTMLDivElement>, import("tailwind-variants").VariantProps<import("tailwind-variants").TVReturnType<{
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, undefined, {
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, import("tailwind-variants").TVReturnType<{
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, undefined, unknown, unknown, undefined>>>>>;
+export declare const Trigger: import("react").ComponentType<import("@ark-ui/react").Assign<Tabs.TriggerProps & import("react").RefAttributes<HTMLButtonElement>, import("tailwind-variants").VariantProps<import("tailwind-variants").TVReturnType<{
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, undefined, {
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, import("tailwind-variants").TVReturnType<{
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, undefined, unknown, unknown, undefined>>>>>;
+export declare const Context: (props: Tabs.ContextProps) => import("react").ReactNode;

package/dist/ui/Tabs/Tabs.jsx

@@ -0,0 +1,11 @@
+'use client';
+import { Tabs } from '@ark-ui/react';
+import { createRecipeContext } from '../../utils/createRecipeContext';
+import { tabsRecipe } from './tabs.recipe';
+var _a = createRecipeContext(tabsRecipe), withContext = _a.withContext, withProvider = _a.withProvider;
+export var Root = withProvider(Tabs.Root, 'root');
+export var Content = withContext(Tabs.Content, 'content');
+export var Indicator = withContext(Tabs.Indicator, 'indicator');
+export var List = withContext(Tabs.List, 'list');
+export var Trigger = withContext(Tabs.Trigger, 'trigger');
+export var Context = Tabs.Context;

package/dist/ui/Tabs/index.d.ts

@@ -0,0 +1 @@
+export * as Tabs from './Tabs';

package/dist/ui/Tabs/index.js

@@ -0,0 +1 @@
+export * as Tabs from './Tabs';

package/dist/ui/Tabs/tabs.recipe.d.ts

@@ -0,0 +1,37 @@
+export declare const tabsRecipe: import("tailwind-variants").TVReturnType<{
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, undefined, {
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, import("tailwind-variants").TVReturnType<{
+    size: {
+        md: {};
+    };
+    variant: {
+        unstyled: {};
+        default: {
+            list: string;
+            indicator: string;
+            trigger: string;
+        };
+    };
+}, Record<"content" | "trigger" | "root" | "indicator" | "list", string | string[]>, undefined, unknown, unknown, undefined>>;

package/dist/ui/Tabs/tabs.recipe.js

@@ -0,0 +1,33 @@
+import { tabsAnatomy } from '@ark-ui/react';
+import { tv } from 'tailwind-variants';
+import { anatomyToRecipeSlots } from '../../utils/anatomyToRecipeSlots';
+export var tabsRecipe = tv({
+    slots: anatomyToRecipeSlots(tabsAnatomy),
+    variants: {
+        size: {
+            md: {},
+        },
+        variant: {
+            unstyled: {},
+            default: {
+                list: 'border-gray-200 bg-gray-50 relative flex w-fit gap-md rounded-md border p-1',
+                indicator: 'h-[var(--height)] w-[var(--width)] bg-white',
+                trigger: 'z-1 text-gray-600 ui-selected:text-gray-800 relative transition-all duration-200',
+            },
+        },
+    },
+    compoundVariants: [
+        {
+            size: 'md',
+            variant: 'default',
+            className: {
+                indicator: 'rounded-sm shadow-sm',
+                trigger: 'px-lg py-md text-sm font-semibold',
+            },
+        },
+    ],
+    defaultVariants: {
+        size: 'md',
+        variant: 'default',
+    },
+});

package/dist/ui/Tooltip/Tooltip.d.ts

@@ -0,0 +1 @@
+export declare const Root: () => null;

package/dist/ui/Tooltip/Tooltip.jsx

@@ -0,0 +1,2 @@
+'use client';
+export var Root = function () { return null; };

package/dist/ui/Tooltip/index.d.ts

@@ -0,0 +1 @@
+export * as Tooltip from './Tooltip';

package/dist/ui/Tooltip/index.js

@@ -0,0 +1 @@
+export * as Tooltip from './Tooltip';

package/dist/ui/Tooltip/tooltip.recipe.js

@@ -0,0 +1 @@
+"use strict";

package/dist/ui/index.d.ts

@@ -0,0 +1,23 @@
+export * from './AlertDialog';
+export * from './Avatar';
+export * from './Badge';
+export * from './Button';
+export * from './Checkbox';
+export * from './Clipboard';
+export * from './Combobox';
+export * from './DatePicker';
+export * from './Dialog';
+export * from './Drawer';
+export * from './Field';
+export * from './IconButton';
+export * from './Menu';
+export * from './NumberInput';
+export * from './PinInput';
+export * from './Popover';
+export * from './Presence';
+export * from './Progress';
+export * from './SegmentGroup';
+export * from './Select';
+export * from './Table';
+export * from './Tabs';
+export * from './Tooltip';

package/dist/ui/index.js

@@ -0,0 +1,23 @@
+export * from './AlertDialog';
+export * from './Avatar';
+export * from './Badge';
+export * from './Button';
+export * from './Checkbox';
+export * from './Clipboard';
+export * from './Combobox';
+export * from './DatePicker';
+export * from './Dialog';
+export * from './Drawer';
+export * from './Field';
+export * from './IconButton';
+export * from './Menu';
+export * from './NumberInput';
+export * from './PinInput';
+export * from './Popover';
+export * from './Presence';
+export * from './Progress';
+export * from './SegmentGroup';
+export * from './Select';
+export * from './Table';
+export * from './Tabs';
+export * from './Tooltip';

package/dist/utils/anatomyToRecipeSlots.d.ts

@@ -0,0 +1,6 @@
+import type { AnatomyInstance } from '@ark-ui/anatomy';
+/**
+ * Converts a component anatomy into a valid tailwind variant slot recipe
+ * and optionally, accepts initial base styles.
+ */
+export declare function anatomyToRecipeSlots<T extends string>(anatomy: AnatomyInstance<T>, baseStyles?: Partial<Record<T, string | string[]>>): Record<T, string | string[]>;

package/dist/utils/anatomyToRecipeSlots.js

@@ -0,0 +1,13 @@
+/**
+ * Converts a component anatomy into a valid tailwind variant slot recipe
+ * and optionally, accepts initial base styles.
+ */
+export function anatomyToRecipeSlots(anatomy, baseStyles) {
+    if (baseStyles === void 0) { baseStyles = {}; }
+    var styles = anatomy.keys().reduce(function (acc, key) {
+        var _a;
+        acc[key] = (_a = baseStyles[key]) !== null && _a !== void 0 ? _a : '';
+        return acc;
+    }, {});
+    return styles;
+}

package/dist/utils/capitalize.d.ts

@@ -0,0 +1,40 @@
+interface CapitalizeConfig {
+    /**
+     * @description The delimiter used to split the string into words.
+     * @default ' '
+     */
+    delimiter?: string | RegExp;
+    /**
+     * @description Whether to convert the string to lowercase before capitalizing.
+     * @default true
+     */
+    lower?: boolean;
+    /**
+     * @description Whether to trim the string before capitalizing.
+     * @default true
+     */
+    trim?: boolean;
+}
+/**
+ * @example
+ * ```ts
+ * capitalize('foo bar baz') // 'Foo Bar Baz'
+ * capitalize('foo_bar_baz', { delimiter: capitalize.delimiters.UNDERSCORE }) // 'Foo Bar Baz'
+ * ```
+ */
+export declare function capitalize(subject: string, config?: CapitalizeConfig): string;
+export declare namespace capitalize {
+    var delimiters: {
+        SPACE: RegExp;
+        UNDERSCORE: RegExp;
+        DASH: RegExp;
+        /**
+         * ```
+         * SpotBonus => Spot Bonus
+         * GenericPromo => Generic Promo
+         * ```
+         */
+        PASCAL: RegExp;
+    };
+}
+export {};

package/dist/utils/capitalize.js

@@ -0,0 +1,47 @@
+var SPACE = /\s/g;
+var UNDERSCORE = /_/g;
+var DASH = /-/g;
+var PASCAL = /(?=[A-Z])/;
+/**
+ * @example
+ * ```ts
+ * capitalize('foo bar baz') // 'Foo Bar Baz'
+ * capitalize('foo_bar_baz', { delimiter: capitalize.delimiters.UNDERSCORE }) // 'Foo Bar Baz'
+ * ```
+ */
+export function capitalize(subject, config) {
+    var _a, _b, _c;
+    var trim = (_a = config === null || config === void 0 ? void 0 : config.trim) !== null && _a !== void 0 ? _a : true;
+    var lower = (_b = config === null || config === void 0 ? void 0 : config.lower) !== null && _b !== void 0 ? _b : true;
+    var delimiter = (_c = config === null || config === void 0 ? void 0 : config.delimiter) !== null && _c !== void 0 ? _c : SPACE;
+    if (trim)
+        subject = subject.trim();
+    if (subject.length < 2) {
+        return subject.toUpperCase();
+    }
+    if (delimiter instanceof RegExp) {
+        delimiter.lastIndex = 0;
+    }
+    return subject
+        .split(delimiter)
+        .map(function (word) {
+        if (word.length < 2)
+            return word.toUpperCase();
+        var firstChar = word.charAt(0).toUpperCase();
+        var otherChars = lower ? word.substring(1).toLowerCase() : word.substring(1);
+        return firstChar.concat(otherChars);
+    })
+        .join(' ');
+}
+capitalize.delimiters = {
+    SPACE: SPACE,
+    UNDERSCORE: UNDERSCORE,
+    DASH: DASH,
+    /**
+     * ```
+     * SpotBonus => Spot Bonus
+     * GenericPromo => Generic Promo
+     * ```
+     */
+    PASCAL: PASCAL,
+};

package/dist/utils/createPoll.d.ts

@@ -0,0 +1,28 @@
+interface CreatePollConfig<T = unknown> {
+    until(response: T): boolean | Promise<boolean>;
+    /**
+     * @default 1000
+     */
+    interval?: number;
+    /**
+     * @default 3
+     */
+    maxAttempt?: number;
+}
+/**
+ * @example
+ * ```ts
+ * const poll = createPoll(
+ *  fn,
+ *  {
+ *    until: (r) => r.ok,
+ *    interval: 1000,
+ *    maxAttempt: 5,
+ *  }
+ * );
+ *
+ * poll()
+ * ```
+ */
+export declare function createPoll<Return, Args = never>(func: (...args: Args[]) => Promise<Return>, config: CreatePollConfig<Return>): (...args: Args[]) => Promise<Return>;
+export {};

package/dist/utils/createPoll.js

@@ -0,0 +1,104 @@
+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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 defaultConfig = {
+    interval: 1000,
+    maxAttempt: 3,
+};
+/**
+ * @example
+ * ```ts
+ * const poll = createPoll(
+ *  fn,
+ *  {
+ *    until: (r) => r.ok,
+ *    interval: 1000,
+ *    maxAttempt: 5,
+ *  }
+ * );
+ *
+ * poll()
+ * ```
+ */
+export function createPoll(func, config) {
+    var _this = this;
+    var _a = Object.assign(defaultConfig, config), until = _a.until, interval = _a.interval, maxAttempt = _a.maxAttempt;
+    function repeater(args, max) {
+        return __awaiter(this, void 0, void 0, function () {
+            var remainingAttempts, result, shouldStop, retryCount, maxJitter, jitter;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        remainingAttempts = max !== null && max !== void 0 ? max : maxAttempt;
+                        return [4 /*yield*/, func.apply(void 0, args)];
+                    case 1:
+                        result = _a.sent();
+                        return [4 /*yield*/, until(result)];
+                    case 2:
+                        shouldStop = _a.sent();
+                        if (shouldStop)
+                            return [2 /*return*/, result];
+                        retryCount = maxAttempt + 1 - remainingAttempts;
+                        maxJitter = interval * Math.pow(2, retryCount);
+                        jitter = Math.random() * maxJitter;
+                        if (!(remainingAttempts > 1)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, sleep(jitter)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/, repeater(args, remainingAttempts - 1)];
+                    case 4: return [2 /*return*/, result];
+                }
+            });
+        });
+    }
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, repeater(args)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+}
+function sleep(ms) {
+    return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+}

package/dist/utils/createRecipeContext.d.ts

@@ -0,0 +1,15 @@
+import type { Assign } from '@ark-ui/react';
+import * as React from 'react';
+import type { VariantProps } from 'tailwind-variants';
+type GenericProps = Record<string, any>;
+type GenericRecipeEntries = Record<string, (props: GenericProps) => string>;
+type GenericRecipe = {
+    (props: GenericProps): GenericRecipeEntries;
+    variantKeys: (string | number | never)[];
+};
+export declare function createRecipeContext<Recipe extends GenericRecipe = GenericRecipe, RecipeProps extends GenericProps = VariantProps<Recipe>, RecipeEntries extends GenericRecipeEntries = ReturnType<Recipe>, RecipeEntry = keyof RecipeEntries>(recipe: Recipe): {
+    withRootProvider: <Props extends GenericProps>(Component: React.ComponentType<Props>) => React.ComponentType<Assign<Props, RecipeProps>>;
+    withProvider: <Props extends GenericProps>(Component: React.ComponentType<Props>, slot: RecipeEntry) => React.ComponentType<Assign<Props, RecipeProps>>;
+    withContext: <Props extends GenericProps>(Component: React.ComponentType<Props>, slot: RecipeEntry) => React.ComponentType<Assign<Props, RecipeProps>>;
+};
+export {};