@rockshin/tao-ui 0.0.1

package/dist/layouts/stack/stack.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+import './layout.css';
+export interface StackProps {
+    direction?: 'vertical' | 'horizontal';
+    gap?: 'sm' | 'md' | 'lg';
+    align?: 'start' | 'center' | 'end' | 'stretch';
+    children: ReactNode;
+}
+export declare function Stack({ direction, gap, align, children, }: StackProps): import("react/jsx-runtime").JSX.Element;

package/dist/layouts/stack/stack.js

@@ -0,0 +1,27 @@
+import { jsx } from "react/jsx-runtime";
+import { c } from "react/compiler-runtime";
+import "./layout.css";
+function Stack(t0) {
+    const $ = c(5);
+    const { direction: t1, gap: t2, align: t3, children } = t0;
+    const direction = void 0 === t1 ? "vertical" : t1;
+    const gap = void 0 === t2 ? "md" : t2;
+    const align = void 0 === t3 ? "stretch" : t3;
+    let t4;
+    if ($[0] !== align || $[1] !== children || $[2] !== direction || $[3] !== gap) {
+        t4 = /*#__PURE__*/ jsx("div", {
+            "data-tao-stack": "",
+            "data-tao-direction": direction,
+            "data-tao-gap": gap,
+            "data-tao-align": align,
+            children: children
+        });
+        $[0] = align;
+        $[1] = children;
+        $[2] = direction;
+        $[3] = gap;
+        $[4] = t4;
+    } else t4 = $[4];
+    return t4;
+}
+export { Stack };

package/dist/number-input/cursor.d.ts

@@ -0,0 +1,9 @@
+export declare function countAnchored(display: string, upTo: number, thousandsSeparator: string): number;
+export declare function findCursorAt(display: string, anchorCount: number, thousandsSeparator: string): number;
+export declare function reposition(args: {
+    before: string;
+    beforeCursor: number;
+    after: string;
+    thousandsSeparator: string;
+}): number;
+export declare function isThousandSepBeforeCursor(display: string, cursor: number, thousandsSeparator: string): boolean;

package/dist/number-input/cursor.js

@@ -0,0 +1,44 @@
+function countAnchored(display, upTo, thousandsSeparator) {
+    const limit = Math.min(upTo, display.length);
+    if (!thousandsSeparator) return Math.max(0, limit);
+    let count = 0;
+    for(let i = 0; i < limit; i++)if (display[i] !== thousandsSeparator) count++;
+    return count;
+}
+function findCursorAt(display, anchorCount, thousandsSeparator) {
+    if (anchorCount <= 0) return 0;
+    if (!thousandsSeparator) return Math.min(anchorCount, display.length);
+    let count = 0;
+    for(let i = 0; i < display.length; i++){
+        if (display[i] !== thousandsSeparator) count++;
+        if (count === anchorCount) return i + 1;
+    }
+    return display.length;
+}
+function countAnchoredFromEnd(display, fromPos, thousandsSeparator) {
+    if (fromPos >= display.length) return 0;
+    if (!thousandsSeparator) return display.length - Math.max(0, fromPos);
+    let count = 0;
+    for(let i = Math.max(0, fromPos); i < display.length; i++)if (display[i] !== thousandsSeparator) count++;
+    return count;
+}
+function findCursorFromEnd(display, anchoredFromEnd, thousandsSeparator) {
+    if (anchoredFromEnd <= 0) return display.length;
+    if (!thousandsSeparator) return Math.max(0, display.length - anchoredFromEnd);
+    let count = 0;
+    for(let i = display.length - 1; i >= 0; i--){
+        if (display[i] !== thousandsSeparator) count++;
+        if (count === anchoredFromEnd) return i;
+    }
+    return 0;
+}
+function reposition(args) {
+    const { before, beforeCursor, after, thousandsSeparator } = args;
+    const fromEnd = countAnchoredFromEnd(before, beforeCursor, thousandsSeparator);
+    return findCursorFromEnd(after, fromEnd, thousandsSeparator);
+}
+function isThousandSepBeforeCursor(display, cursor, thousandsSeparator) {
+    if (!thousandsSeparator || cursor <= 0) return false;
+    return display[cursor - 1] === thousandsSeparator;
+}
+export { countAnchored, findCursorAt, isThousandSepBeforeCursor, reposition };

package/dist/number-input/format.d.ts

@@ -0,0 +1,5 @@
+import type { FormatOptions, PadDecimalsOnBlur } from './types';
+export declare function format(canonical: string, opts: FormatOptions): string;
+export declare function parse(display: string, opts: FormatOptions): string;
+export declare function truncateDecimals(canonical: string, decimalPlaces: number): string;
+export declare function padOnBlur(canonical: string, decimalPlaces: number, mode: PadDecimalsOnBlur): string;

package/dist/number-input/format.js

@@ -0,0 +1,50 @@
+const THOUSAND_SEP_REGEX = /\B(?=(\d{3})+(?!\d))/g;
+function format(canonical, opts) {
+    if ('' === canonical || '-' === canonical) return canonical;
+    const negative = canonical.startsWith('-');
+    const abs = negative ? canonical.slice(1) : canonical;
+    const dotIndex = abs.indexOf('.');
+    const intPart = -1 === dotIndex ? abs : abs.slice(0, dotIndex);
+    const fracPart = -1 === dotIndex ? '' : abs.slice(dotIndex + 1);
+    const groupedInt = opts.thousandsSeparator ? intPart.replace(THOUSAND_SEP_REGEX, opts.thousandsSeparator) : intPart;
+    let result = groupedInt;
+    if (-1 !== dotIndex) result += opts.decimalSeparator + fracPart;
+    return (negative ? '-' : '') + result;
+}
+function parse(display, opts) {
+    if (!display) return '';
+    const negative = display.startsWith('-');
+    const body = negative ? display.slice(1) : display;
+    let cleaned = '';
+    let seenDecimal = false;
+    for (const ch of body)if (ch >= '0' && ch <= '9') cleaned += ch;
+    else if (ch === opts.decimalSeparator && !seenDecimal) {
+        cleaned += '.';
+        seenDecimal = true;
+    }
+    if (cleaned.startsWith('.')) cleaned = `0${cleaned}`;
+    return (negative ? '-' : '') + cleaned;
+}
+function truncateDecimals(canonical, decimalPlaces) {
+    const dotIndex = canonical.indexOf('.');
+    if (-1 === dotIndex) return canonical;
+    if (0 === decimalPlaces) return canonical.slice(0, dotIndex);
+    return canonical.slice(0, dotIndex + 1 + decimalPlaces);
+}
+function padOnBlur(canonical, decimalPlaces, mode) {
+    if ('never' === mode) return canonical;
+    if ('' === canonical || '-' === canonical) return canonical;
+    const dotIndex = canonical.indexOf('.');
+    const hasDot = -1 !== dotIndex;
+    const fracLen = hasDot ? canonical.length - dotIndex - 1 : 0;
+    if ('whenHasDecimal' === mode) {
+        if (!hasDot || 0 === fracLen) return hasDot ? canonical.slice(0, dotIndex) : canonical;
+        if (fracLen >= decimalPlaces) return canonical;
+        return canonical + '0'.repeat(decimalPlaces - fracLen);
+    }
+    if (0 === decimalPlaces) return hasDot ? canonical.slice(0, dotIndex) : canonical;
+    if (!hasDot) return `${canonical}.${'0'.repeat(decimalPlaces)}`;
+    if (fracLen >= decimalPlaces) return canonical;
+    return canonical + '0'.repeat(decimalPlaces - fracLen);
+}
+export { format, padOnBlur, parse, truncateDecimals };

package/dist/number-input/index.d.ts

@@ -0,0 +1,5 @@
+export type { NumberInputProps } from './number-input';
+export { NumberInput } from './number-input';
+export type { FormatOptions, PadDecimalsOnBlur } from './types';
+export type { UseNumberInputOptions, UseNumberInputReturn, } from './use-number-input';
+export { useNumberInput } from './use-number-input';

package/dist/number-input/index.js

@@ -0,0 +1,2 @@
+export { NumberInput } from "./number-input.js";
+export { useNumberInput } from "./use-number-input.js";

package/dist/number-input/number-input.d.ts

@@ -0,0 +1,9 @@
+import type { InputHTMLAttributes, ReactNode } from 'react';
+import { type UseNumberInputOptions } from './use-number-input';
+export interface NumberInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'onChange' | 'onBlur' | 'min' | 'max' | 'prefix'>, UseNumberInputOptions {
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    containerClassName?: string;
+    className?: string;
+}
+export declare function NumberInput(props: NumberInputProps): import("react/jsx-runtime").JSX.Element;

package/dist/number-input/number-input.js

@@ -0,0 +1,101 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { c } from "react/compiler-runtime";
+import { useNumberInput } from "./use-number-input.js";
+const HOOK_KEYS = [
+    'value',
+    'defaultValue',
+    'onChange',
+    'onBlur',
+    'decimalSeparator',
+    'thousandsSeparator',
+    'decimalPlaces',
+    'padDecimalsOnBlur',
+    'isPercentage',
+    'allowNegative',
+    'min',
+    'max'
+];
+function NumberInput(props) {
+    const $ = c(20);
+    let className;
+    let containerClassName;
+    let hookOpts;
+    let nativeAttrs;
+    let prefix;
+    let suffix;
+    if ($[0] !== props) {
+        const { prefix: t0, suffix: t1, containerClassName: t2, className: t3, ...rest } = props;
+        prefix = t0;
+        suffix = t1;
+        containerClassName = t2;
+        className = t3;
+        hookOpts = {};
+        nativeAttrs = {};
+        for (const [key, val] of Object.entries(rest))if (HOOK_KEYS.includes(key)) hookOpts[key] = val;
+        else nativeAttrs[key] = val;
+        $[0] = props;
+        $[1] = className;
+        $[2] = containerClassName;
+        $[3] = hookOpts;
+        $[4] = nativeAttrs;
+        $[5] = prefix;
+        $[6] = suffix;
+    } else {
+        className = $[1];
+        containerClassName = $[2];
+        hookOpts = $[3];
+        nativeAttrs = $[4];
+        prefix = $[5];
+        suffix = $[6];
+    }
+    const { inputProps } = useNumberInput(hookOpts);
+    let t0;
+    if ($[7] !== prefix) {
+        t0 = void 0 !== prefix && /*#__PURE__*/ jsx("span", {
+            "data-tao-prefix": "",
+            children: prefix
+        });
+        $[7] = prefix;
+        $[8] = t0;
+    } else t0 = $[8];
+    let t1;
+    if ($[9] !== className || $[10] !== inputProps || $[11] !== nativeAttrs) {
+        t1 = /*#__PURE__*/ jsx("input", {
+            ...nativeAttrs,
+            ...inputProps,
+            className: className
+        });
+        $[9] = className;
+        $[10] = inputProps;
+        $[11] = nativeAttrs;
+        $[12] = t1;
+    } else t1 = $[12];
+    let t2;
+    if ($[13] !== suffix) {
+        t2 = void 0 !== suffix && /*#__PURE__*/ jsx("span", {
+            "data-tao-suffix": "",
+            children: suffix
+        });
+        $[13] = suffix;
+        $[14] = t2;
+    } else t2 = $[14];
+    let t3;
+    if ($[15] !== containerClassName || $[16] !== t0 || $[17] !== t1 || $[18] !== t2) {
+        t3 = /*#__PURE__*/ jsxs("span", {
+            className: containerClassName,
+            "data-tao-number-input": "",
+            children: [
+                t0,
+                t1,
+                t2
+            ]
+        });
+        $[15] = containerClassName;
+        $[16] = t0;
+        $[17] = t1;
+        $[18] = t2;
+        $[19] = t3;
+    } else t3 = $[19];
+    return t3;
+}
+export { NumberInput };

package/dist/number-input/percentage.d.ts

@@ -0,0 +1,3 @@
+export declare function shiftDecimal(value: string, places: number): string;
+export declare function fromPercent(displayValue: string): string;
+export declare function toPercent(actualValue: string): string;

package/dist/number-input/percentage.js

@@ -0,0 +1,28 @@
+function shiftDecimal(value, places) {
+    if (0 === places) return value;
+    if ('' === value || '-' === value) return value;
+    const negative = value.startsWith('-');
+    const abs = negative ? value.slice(1) : value;
+    const [intPart = '0', fracPart = ''] = abs.split('.');
+    const digits = intPart + fracPart;
+    const newDecimalPos = intPart.length + places;
+    let result;
+    result = newDecimalPos <= 0 ? `0.${'0'.repeat(-newDecimalPos)}${digits}` : newDecimalPos >= digits.length ? digits + '0'.repeat(newDecimalPos - digits.length) : `${digits.slice(0, newDecimalPos)}.${digits.slice(newDecimalPos)}`;
+    return (negative ? '-' : '') + cleanup(result);
+}
+function fromPercent(displayValue) {
+    return shiftDecimal(displayValue, -2);
+}
+function toPercent(actualValue) {
+    return shiftDecimal(actualValue, 2);
+}
+function cleanup(s) {
+    if (s.includes('.')) {
+        s = s.replace(/0+$/, '');
+        s = s.replace(/\.$/, '');
+    }
+    s = s.replace(/^0+(?=\d)/, '');
+    if ('' === s) return '0';
+    return s;
+}
+export { fromPercent, shiftDecimal, toPercent };

package/dist/number-input/types.d.ts

@@ -0,0 +1,5 @@
+export type PadDecimalsOnBlur = 'never' | 'always' | 'whenHasDecimal';
+export interface FormatOptions {
+    decimalSeparator: '.' | ',';
+    thousandsSeparator: ',' | '.' | "'" | ' ' | '';
+}

package/dist/number-input/use-number-input.d.ts

@@ -0,0 +1,30 @@
+import { type ChangeEvent, type FocusEvent, type KeyboardEvent, type RefObject } from 'react';
+import type { PadDecimalsOnBlur } from './types';
+export interface UseNumberInputOptions {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onBlur?: (value: string) => void;
+    decimalSeparator?: '.' | ',';
+    thousandsSeparator?: ',' | '.' | "'" | ' ' | '';
+    decimalPlaces?: number;
+    padDecimalsOnBlur?: PadDecimalsOnBlur;
+    isPercentage?: boolean;
+    allowNegative?: boolean;
+    min?: number;
+    max?: number;
+}
+export interface UseNumberInputReturn {
+    inputProps: {
+        value: string;
+        onChange: (e: ChangeEvent<HTMLInputElement>) => void;
+        onBlur: (e: FocusEvent<HTMLInputElement>) => void;
+        onFocus: (e: FocusEvent<HTMLInputElement>) => void;
+        onKeyDown: (e: KeyboardEvent<HTMLInputElement>) => void;
+        ref: RefObject<HTMLInputElement | null>;
+        inputMode: 'decimal' | 'numeric';
+    };
+    value: string;
+    displayValue: string;
+}
+export declare function useNumberInput(opts: UseNumberInputOptions): UseNumberInputReturn;

package/dist/number-input/use-number-input.js

@@ -0,0 +1,211 @@
+import { c } from "react/compiler-runtime";
+import { useEffect, useLayoutEffect, useRef, useState } from "react";
+import { isThousandSepBeforeCursor, reposition } from "./cursor.js";
+import { format, padOnBlur, parse, truncateDecimals } from "./format.js";
+import { fromPercent, toPercent } from "./percentage.js";
+import { clampToRange, isValidCanonical, stripDisallowedSign } from "./validate.js";
+function useNumberInput(opts) {
+    const $ = c(53);
+    const { value, defaultValue, onChange, onBlur, decimalSeparator: t0, thousandsSeparator: t1, decimalPlaces: t2, padDecimalsOnBlur: t3, isPercentage: t4, allowNegative: t5, min, max } = opts;
+    const decimalSeparator = void 0 === t0 ? "." : t0;
+    const thousandsSeparator = void 0 === t1 ? "," : t1;
+    const decimalPlaces = void 0 === t2 ? 2 : t2;
+    const padMode = void 0 === t3 ? "never" : t3;
+    const isPercentage = void 0 === t4 ? false : t4;
+    const allowNegative = void 0 === t5 ? false : t5;
+    let t6;
+    if ($[0] !== decimalSeparator || $[1] !== thousandsSeparator) {
+        t6 = {
+            decimalSeparator,
+            thousandsSeparator
+        };
+        $[0] = decimalSeparator;
+        $[1] = thousandsSeparator;
+        $[2] = t6;
+    } else t6 = $[2];
+    const fmtOpts = t6;
+    let t7;
+    if ($[3] !== fmtOpts || $[4] !== isPercentage) {
+        t7 = (actual)=>{
+            const canonical = isPercentage ? toPercent(actual) : actual;
+            return format(canonical, fmtOpts);
+        };
+        $[3] = fmtOpts;
+        $[4] = isPercentage;
+        $[5] = t7;
+    } else t7 = $[5];
+    const canonicalToDisplay = t7;
+    let t8;
+    if ($[6] !== canonicalToDisplay || $[7] !== defaultValue || $[8] !== value) {
+        t8 = ()=>canonicalToDisplay(value ?? defaultValue ?? "");
+        $[6] = canonicalToDisplay;
+        $[7] = defaultValue;
+        $[8] = value;
+        $[9] = t8;
+    } else t8 = $[9];
+    const [displayBuffer, setDisplayBuffer] = useState(t8);
+    const isFocusedRef = useRef(false);
+    const inputRef = useRef(null);
+    const pendingCursorRef = useRef(null);
+    let t9;
+    if ($[10] !== canonicalToDisplay || $[11] !== value) {
+        t9 = ()=>{
+            if (void 0 === value) return;
+            if (isFocusedRef.current) return;
+            const display = canonicalToDisplay(value);
+            setDisplayBuffer((prev)=>prev === display ? prev : display);
+        };
+        $[10] = canonicalToDisplay;
+        $[11] = value;
+        $[12] = t9;
+    } else t9 = $[12];
+    let t10;
+    if ($[13] !== value) {
+        t10 = [
+            value
+        ];
+        $[13] = value;
+        $[14] = t10;
+    } else t10 = $[14];
+    useEffect(t9, t10);
+    let t11;
+    if ($[15] === Symbol.for("react.memo_cache_sentinel")) {
+        t11 = ()=>{
+            if (null === pendingCursorRef.current) return;
+            const pos = pendingCursorRef.current;
+            inputRef.current?.setSelectionRange(pos, pos);
+            pendingCursorRef.current = null;
+        };
+        $[15] = t11;
+    } else t11 = $[15];
+    let t12;
+    if ($[16] !== displayBuffer) {
+        t12 = [
+            displayBuffer
+        ];
+        $[16] = displayBuffer;
+        $[17] = t12;
+    } else t12 = $[17];
+    useLayoutEffect(t11, t12);
+    let t13;
+    if ($[18] !== allowNegative || $[19] !== decimalPlaces || $[20] !== fmtOpts || $[21] !== isPercentage || $[22] !== onChange || $[23] !== thousandsSeparator) {
+        t13 = (e)=>{
+            const raw = e.target.value;
+            const cursor = e.target.selectionStart ?? raw.length;
+            let canonical_0 = parse(raw, fmtOpts);
+            canonical_0 = stripDisallowedSign(canonical_0, allowNegative);
+            canonical_0 = truncateDecimals(canonical_0, decimalPlaces);
+            if (!isValidCanonical(canonical_0)) return;
+            const newDisplay = format(canonical_0, fmtOpts);
+            pendingCursorRef.current = reposition({
+                before: raw,
+                beforeCursor: cursor,
+                after: newDisplay,
+                thousandsSeparator
+            });
+            setDisplayBuffer(newDisplay);
+            const actual_0 = isPercentage ? fromPercent(canonical_0) : canonical_0;
+            onChange?.(actual_0);
+        };
+        $[18] = allowNegative;
+        $[19] = decimalPlaces;
+        $[20] = fmtOpts;
+        $[21] = isPercentage;
+        $[22] = onChange;
+        $[23] = thousandsSeparator;
+        $[24] = t13;
+    } else t13 = $[24];
+    const handleChange = t13;
+    let t14;
+    if ($[25] !== decimalPlaces || $[26] !== displayBuffer || $[27] !== fmtOpts || $[28] !== isPercentage || $[29] !== max || $[30] !== min || $[31] !== onBlur || $[32] !== onChange || $[33] !== padMode) {
+        t14 = ()=>{
+            isFocusedRef.current = false;
+            const raw_0 = inputRef.current?.value ?? displayBuffer;
+            let canonical_1 = parse(raw_0, fmtOpts);
+            canonical_1 = padOnBlur(canonical_1, decimalPlaces, padMode);
+            let actual_1 = isPercentage ? fromPercent(canonical_1) : canonical_1;
+            actual_1 = clampToRange(actual_1, min, max);
+            const canonicalAfter = isPercentage ? toPercent(actual_1) : actual_1;
+            const newDisplay_0 = format(canonicalAfter, fmtOpts);
+            setDisplayBuffer(newDisplay_0);
+            onChange?.(actual_1);
+            onBlur?.(actual_1);
+        };
+        $[25] = decimalPlaces;
+        $[26] = displayBuffer;
+        $[27] = fmtOpts;
+        $[28] = isPercentage;
+        $[29] = max;
+        $[30] = min;
+        $[31] = onBlur;
+        $[32] = onChange;
+        $[33] = padMode;
+        $[34] = t14;
+    } else t14 = $[34];
+    const handleBlur = t14;
+    let t15;
+    if ($[35] === Symbol.for("react.memo_cache_sentinel")) {
+        t15 = ()=>{
+            isFocusedRef.current = true;
+        };
+        $[35] = t15;
+    } else t15 = $[35];
+    const handleFocus = t15;
+    let t16;
+    if ($[36] !== displayBuffer || $[37] !== thousandsSeparator) {
+        t16 = (e_0)=>{
+            if ("Backspace" !== e_0.key) return;
+            const el = inputRef.current;
+            if (!el) return;
+            const cursor_0 = el.selectionStart ?? 0;
+            if (cursor_0 > 0 && isThousandSepBeforeCursor(displayBuffer, cursor_0, thousandsSeparator)) el.setSelectionRange(cursor_0 - 1, cursor_0 - 1);
+        };
+        $[36] = displayBuffer;
+        $[37] = thousandsSeparator;
+        $[38] = t16;
+    } else t16 = $[38];
+    const handleKeyDown = t16;
+    let t17;
+    if ($[39] !== displayBuffer || $[40] !== fmtOpts || $[41] !== isPercentage) {
+        const canonical_2 = parse(displayBuffer, fmtOpts);
+        t17 = isPercentage ? fromPercent(canonical_2) : canonical_2;
+        $[39] = displayBuffer;
+        $[40] = fmtOpts;
+        $[41] = isPercentage;
+        $[42] = t17;
+    } else t17 = $[42];
+    const derivedActual = t17;
+    const t18 = decimalPlaces > 0 ? "decimal" : "numeric";
+    let t19;
+    if ($[43] !== displayBuffer || $[44] !== handleBlur || $[45] !== handleChange || $[46] !== handleKeyDown || $[47] !== t18) {
+        t19 = {
+            value: displayBuffer,
+            onChange: handleChange,
+            onBlur: handleBlur,
+            onFocus: handleFocus,
+            onKeyDown: handleKeyDown,
+            ref: inputRef,
+            inputMode: t18
+        };
+        $[43] = displayBuffer;
+        $[44] = handleBlur;
+        $[45] = handleChange;
+        $[46] = handleKeyDown;
+        $[47] = t18;
+        $[48] = t19;
+    } else t19 = $[48];
+    let t20;
+    if ($[49] !== derivedActual || $[50] !== displayBuffer || $[51] !== t19) {
+        t20 = {
+            inputProps: t19,
+            value: derivedActual,
+            displayValue: displayBuffer
+        };
+        $[49] = derivedActual;
+        $[50] = displayBuffer;
+        $[51] = t19;
+        $[52] = t20;
+    } else t20 = $[52];
+    return t20;
+}
+export { useNumberInput };

package/dist/number-input/validate.d.ts

@@ -0,0 +1,3 @@
+export declare function isValidCanonical(canonical: string): boolean;
+export declare function stripDisallowedSign(canonical: string, allowNegative: boolean): string;
+export declare function clampToRange(canonical: string, min: number | undefined, max: number | undefined): string;

package/dist/number-input/validate.js

@@ -0,0 +1,17 @@
+const CANONICAL_REGEX = /^-?\d*\.?\d*$/;
+function isValidCanonical(canonical) {
+    return CANONICAL_REGEX.test(canonical);
+}
+function stripDisallowedSign(canonical, allowNegative) {
+    if (allowNegative) return canonical;
+    return canonical.startsWith('-') ? canonical.slice(1) : canonical;
+}
+function clampToRange(canonical, min, max) {
+    if ('' === canonical || '-' === canonical) return canonical;
+    const n = Number(canonical);
+    if (!Number.isFinite(n)) return canonical;
+    if (void 0 !== min && n < min) return String(min);
+    if (void 0 !== max && n > max) return String(max);
+    return canonical;
+}
+export { clampToRange, isValidCanonical, stripDisallowedSign };

package/dist/provider/tao-provider.d.ts

@@ -0,0 +1,42 @@
+import { type ReactNode } from 'react';
+export interface TaoSeedToken {
+    colorPrimary?: string;
+    colorSuccess?: string;
+    colorWarning?: string;
+    colorError?: string;
+    colorBgBase?: string;
+    colorTextBase?: string;
+    borderRadius?: number;
+    fontSize?: number;
+    controlHeight?: number;
+    sizeUnit?: number;
+    sizeStep?: number;
+    lineWidth?: number;
+    fontFamily?: string;
+    fontFamilyCode?: string;
+    motionUnit?: number;
+    motion?: boolean;
+    zIndexBase?: number;
+    zIndexPopupBase?: number;
+}
+export interface TaoThemeConfig {
+    token?: Partial<TaoSeedToken>;
+    inherit?: boolean;
+}
+export type TaoSize = 'small' | 'medium' | 'large';
+export type TaoVariant = 'outlined' | 'filled' | 'borderless';
+interface TaoConfigContextValue {
+    size: TaoSize;
+    disabled: boolean;
+    variant: TaoVariant;
+}
+export declare function useTaoConfig(): TaoConfigContextValue;
+export interface TaoProviderProps {
+    children: ReactNode;
+    theme?: TaoThemeConfig;
+    size?: TaoSize;
+    disabled?: boolean;
+    variant?: TaoVariant;
+}
+export declare function TaoProvider({ theme, size, disabled, variant, children, }: TaoProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};