@laser-ui/components 0.0.1

package/cascader/internal/CascaderSearchPanel.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import type { CascaderSearchPanelItem } from './types';
+import type { Styled } from '../../hooks/useStyled';
+import type { CascaderItem } from '../types';
+import type { CLASSES } from '../vars';
+interface CascaderSearchPanelProps<V extends React.Key, T extends CascaderItem<V>> {
+    namespace: string;
+    styled: Styled<typeof CLASSES>;
+    id: string;
+    list: CascaderSearchPanelItem<V, T>[];
+    customItem: ((item: T) => React.ReactNode) | undefined;
+    itemId: (value: V) => string;
+    itemFocused: CascaderSearchPanelItem<V, T> | undefined;
+    multiple: boolean;
+    onlyLeafSelectable: boolean;
+    virtual: boolean | number;
+    focusVisible: boolean;
+    onClick: (item: CascaderSearchPanelItem<V, T>) => void;
+}
+declare function CascaderSearchPanelFC<V extends React.Key, T extends CascaderItem<V>>(props: CascaderSearchPanelProps<V, T>, ref: React.ForwardedRef<any>): JSX.Element | null;
+export declare const CascaderSearchPanel: <V extends React.Key, T extends CascaderItem<V>>(props: CascaderSearchPanelProps<V, T> & React.RefAttributes<any>) => ReturnType<typeof CascaderSearchPanelFC>;
+export {};

package/cascader/internal/CascaderSearchPanel.js

@@ -0,0 +1,73 @@
+import { createElement as _createElement } from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEventCallback } from '@laser-ui/hooks';
+import { scrollIntoViewIfNeeded } from '@laser-ui/utils';
+import { isNumber, isUndefined } from 'lodash';
+import { forwardRef, useImperativeHandle, useMemo, useRef } from 'react';
+import { Checkbox } from '../../checkbox';
+import { Empty } from '../../empty';
+import { getTreeNodeLabel } from '../../tree/utils';
+import { TREE_NODE_KEY } from '../../tree/vars';
+import { VirtualScroll } from '../../virtual-scroll';
+function CascaderSearchPanelFC(props, ref) {
+    const { namespace, styled, id, list, customItem, itemId, itemFocused, multiple, onlyLeafSelectable, virtual, focusVisible, onClick } = props;
+    const listRef = useRef(null);
+    const vsRef = useRef(null);
+    const handleKeyDown = useEventCallback((code) => {
+        var _a, _b, _c, _d;
+        if (listRef.current) {
+            let item;
+            switch (code) {
+                case 'next':
+                    item = (_a = vsRef.current) === null || _a === void 0 ? void 0 : _a.scrollToStep(listRef.current, 1);
+                    break;
+                case 'prev':
+                    item = (_b = vsRef.current) === null || _b === void 0 ? void 0 : _b.scrollToStep(listRef.current, -1);
+                    break;
+                case 'first':
+                    item = (_c = vsRef.current) === null || _c === void 0 ? void 0 : _c.scrollToStart(listRef.current);
+                    break;
+                case 'last':
+                    item = (_d = vsRef.current) === null || _d === void 0 ? void 0 : _d.scrollToEnd(listRef.current);
+                    break;
+                default:
+                    if (code instanceof HTMLElement && listRef.current) {
+                        scrollIntoViewIfNeeded(code, listRef.current);
+                    }
+                    break;
+            }
+            return item;
+        }
+    });
+    useImperativeHandle(ref, () => handleKeyDown, [handleKeyDown]);
+    const vsProps = useMemo(() => ({
+        list,
+        itemKey: (item) => item.value,
+        itemSize: isNumber(virtual) ? virtual : 32,
+        itemFocusable: (item) => item[TREE_NODE_KEY].enabled,
+    }), [list, virtual]);
+    return (_jsx(VirtualScroll, Object.assign({}, vsProps, { ref: vsRef, enable: virtual !== false, listSize: 264, listPadding: 4, itemRender: (item, index, props) => {
+            const node = item[TREE_NODE_KEY];
+            let inSelected = node.checked;
+            if (!onlyLeafSelectable) {
+                let n = node;
+                while (n.parent) {
+                    n = n.parent;
+                    if (n.id === item.value) {
+                        inSelected = true;
+                        break;
+                    }
+                }
+            }
+            return (_createElement("li", Object.assign({}, styled('cascader__option', {
+                'cascader__option.is-selected': !multiple && inSelected,
+                'cascader__option.is-disabled': node.disabled,
+            }), props, { key: item.value, id: itemId(item.value), title: item.label, role: "option", "aria-selected": node.checked, "aria-disabled": node.disabled, onClick: () => {
+                    onClick(item);
+                } }),
+                focusVisible && (itemFocused === null || itemFocused === void 0 ? void 0 : itemFocused.value) === item.value && _jsx("div", { className: `${namespace}-focus-outline` }),
+                multiple && (_jsx("div", Object.assign({}, styled('cascader__option-prefix'), { children: _jsx(Checkbox, { model: node.checked, disabled: node.disabled }) }))),
+                _jsx("div", Object.assign({}, styled('cascader__option-content'), { children: customItem ? customItem(node.origin) : getTreeNodeLabel(node) }))));
+        }, itemFocused: itemFocused === null || itemFocused === void 0 ? void 0 : itemFocused.value, placeholder: "li", children: (vsList, onScroll) => (_jsx("ul", Object.assign({}, styled('cascader__list'), { ref: listRef, id: id, tabIndex: -1, role: "listbox", "aria-multiselectable": multiple, "aria-activedescendant": isUndefined(itemFocused) ? undefined : itemId(itemFocused.value), onScroll: onScroll, children: list.length === 0 ? _jsx(Empty, { style: { padding: '12px 28px' }, image: Empty.SIMPLE_IMG }) : vsList }))) })));
+}
+export const CascaderSearchPanel = forwardRef(CascaderSearchPanelFC);

package/cascader/internal/types.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import type { SelectItem } from '../../select/types';
+import type { AbstractTreeNode } from '../../tree/node/abstract-node';
+import type { TreeNode } from '../../tree/node/types';
+import type { TREE_NODE_KEY } from '../../tree/vars';
+export type CascaderSearchPanelItem<V extends React.Key, T extends TreeNode> = SelectItem<V> & {
+    [TREE_NODE_KEY]: AbstractTreeNode<V, T>;
+};

package/cascader/internal/types.js

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

package/cascader/types.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="react" />
+import type { CLASSES } from './vars';
+import type { FormControlProvider } from '../form/types';
+import type { BaseProps, CloneHTMLElement, Size } from '../types';
+export {};
+export interface CascaderRef {
+    updatePosition: () => void;
+}
+export interface CascaderItem<V extends React.Key> {
+    label: string;
+    value: V;
+    loading?: boolean;
+    disabled?: boolean;
+    children?: CascaderItem<V>[];
+}
+export interface CascaderProps<V extends React.Key, T extends CascaderItem<V>> extends BaseProps<'cascader' | 'cascader-popup', typeof CLASSES>, Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    formControl?: FormControlProvider;
+    list: T[];
+    model?: V | null | V[];
+    defaultModel?: V | null | V[];
+    visible?: boolean;
+    defaultVisible?: boolean;
+    placeholder?: string;
+    multiple?: boolean;
+    searchable?: boolean;
+    searchValue?: string;
+    defaultSearchValue?: string;
+    onlyLeafSelectable?: boolean;
+    clearable?: boolean;
+    loading?: boolean;
+    size?: Size;
+    disabled?: boolean;
+    virtual?: boolean | number;
+    escClosable?: boolean;
+    customItem?: (item: T) => React.ReactNode;
+    customSelected?: (selected: T) => string;
+    customSearch?: {
+        filter?: (value: string, item: T) => boolean;
+        sort?: (a: T, b: T) => number;
+    };
+    inputRef?: React.ForwardedRef<HTMLInputElement>;
+    inputRender?: CloneHTMLElement;
+    onModelChange?: (value: any, origin: any) => void;
+    onVisibleChange?: (visible: boolean) => void;
+    onSearch?: (value: string) => void;
+    onClear?: () => void;
+    onFirstFocus?: (value: V, origin: T) => void;
+    afterVisibleChange?: (visible: boolean) => void;
+}

package/cascader/types.js

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

package/cascader/vars.d.ts

@@ -0,0 +1,32 @@
+export declare const CLASSES: {
+    cascader: string;
+    'cascader.is-expanded': string;
+    'cascader.is-disabled': string;
+    'cascader--small': string;
+    'cascader--medium': string;
+    'cascader--large': string;
+    cascader__container: string;
+    cascader__content: string;
+    cascader__search: string;
+    'cascader__placeholder-wrapper': string;
+    cascader__placeholder: string;
+    'cascader__multiple-count': string;
+    cascader__close: string;
+    cascader__clear: string;
+    cascader__icon: string;
+    cascader__arrow: string;
+    'cascader-popup': string;
+    'cascader-popup__loading': string;
+    'cascader-popup__loading--empty': string;
+    cascader__list: string;
+    'cascader__list--inline': string;
+    cascader__option: string;
+    'cascader__option.is-focused': string;
+    'cascader__option.is-selected': string;
+    'cascader__option.is-disabled': string;
+    'cascader__option-dot': string;
+    'cascader__option-prefix': string;
+    'cascader__option-content': string;
+    'cascader__option-icon': string;
+    cascader__empty: string;
+};

package/cascader/vars.js

@@ -0,0 +1,32 @@
+export const CLASSES = {
+    cascader: '^cascader',
+    'cascader.is-expanded': 'is-expanded',
+    'cascader.is-disabled': 'is-disabled',
+    'cascader--small': '^cascader--small',
+    'cascader--medium': '^cascader--medium',
+    'cascader--large': '^cascader--large',
+    cascader__container: '^cascader__container',
+    cascader__content: '^cascader__content',
+    cascader__search: '^cascader__search',
+    'cascader__placeholder-wrapper': '^cascader__placeholder-wrapper',
+    cascader__placeholder: '^cascader__placeholder',
+    'cascader__multiple-count': '^cascader__multiple-count',
+    cascader__close: '^cascader__close',
+    cascader__clear: '^cascader__clear',
+    cascader__icon: '^cascader__icon',
+    cascader__arrow: '^cascader__arrow',
+    'cascader-popup': '^cascader-popup',
+    'cascader-popup__loading': '^cascader-popup__loading',
+    'cascader-popup__loading--empty': '^cascader-popup__loading--empty',
+    cascader__list: '^cascader__list',
+    'cascader__list--inline': '^cascader__list--inline',
+    cascader__option: '^cascader__option',
+    'cascader__option.is-focused': 'is-focused',
+    'cascader__option.is-selected': 'is-selected',
+    'cascader__option.is-disabled': 'is-disabled',
+    'cascader__option-dot': '^cascader__option-dot',
+    'cascader__option-prefix': '^cascader__option-prefix',
+    'cascader__option-content': '^cascader__option-content',
+    'cascader__option-icon': '^cascader__option-icon',
+    cascader__empty: '^cascader__empty',
+};

package/checkbox/Checkbox.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { CheckboxProps } from './types';
+import { CheckboxGroup } from './CheckboxGroup';
+export declare const Checkbox: {
+    (props: CheckboxProps): JSX.Element | null;
+    Group: typeof CheckboxGroup;
+};

package/checkbox/Checkbox.js

@@ -0,0 +1,25 @@
+import { __rest } from "tslib";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { checkNodeExist } from '@laser-ui/utils';
+import { CheckboxGroup } from './CheckboxGroup';
+import { CLASSES } from './vars';
+import { useComponentProps, useControlled, useScopedProps, useStyled } from '../hooks';
+import { mergeCS } from '../utils';
+export const Checkbox = (props) => {
+    const _a = useComponentProps('Checkbox', props), { children, styleOverrides, styleProvider, formControl, model, defaultModel, indeterminate = false, disabled: disabledProp = false, inputRef, inputRender, onModelChange } = _a, restProps = __rest(_a, ["children", "styleOverrides", "styleProvider", "formControl", "model", "defaultModel", "indeterminate", "disabled", "inputRef", "inputRender", "onModelChange"]);
+    const styled = useStyled(CLASSES, { checkbox: styleProvider === null || styleProvider === void 0 ? void 0 : styleProvider.checkbox }, styleOverrides);
+    const [checked, changeChecked] = useControlled(defaultModel !== null && defaultModel !== void 0 ? defaultModel : false, model, onModelChange, undefined, formControl === null || formControl === void 0 ? void 0 : formControl.control);
+    const { disabled } = useScopedProps({ disabled: disabledProp || (formControl === null || formControl === void 0 ? void 0 : formControl.control.disabled) });
+    const inputNode = (_jsx("input", Object.assign({}, styled('checkbox__input'), formControl === null || formControl === void 0 ? void 0 : formControl.inputAria, { ref: inputRef, type: "checkbox", disabled: disabled, "aria-checked": indeterminate ? 'mixed' : checked, onChange: () => {
+            changeChecked((draft) => !draft);
+        } })));
+    return (_jsxs("label", Object.assign({}, restProps, mergeCS(styled('checkbox', {
+        'checkbox.is-checked': checked,
+        'checkbox.is-indeterminate': indeterminate,
+        'checkbox.is-disabled': disabled,
+    }), {
+        className: restProps.className,
+        style: restProps.style,
+    }), { children: [_jsxs("div", Object.assign({}, styled('checkbox__state-container'), { children: [inputRender ? inputRender(inputNode) : inputNode, indeterminate ? _jsx("div", Object.assign({}, styled('checkbox__indeterminate'))) : checked && _jsx("div", Object.assign({}, styled('checkbox__tick')))] })), checkNodeExist(children) && _jsx("div", Object.assign({}, styled('checkbox__label'), { children: children }))] })));
+};
+Checkbox.Group = CheckboxGroup;

package/checkbox/CheckboxGroup.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { CheckboxGroupItem, CheckboxGroupProps } from './types';
+export declare function CheckboxGroup<V extends React.Key, T extends CheckboxGroupItem<V>>(props: CheckboxGroupProps<V, T>): JSX.Element | null;

package/checkbox/CheckboxGroup.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cloneElement } from 'react';
+import { Checkbox } from './Checkbox';
+import { useComponentProps, useControlled, useScopedProps } from '../hooks';
+export function CheckboxGroup(props) {
+    var _a;
+    const { children, formControl, list, model, defaultModel, disabled: disabledProp = false, onModelChange, } = useComponentProps('CheckboxGroup', props);
+    const [values, changeValues] = useControlled(defaultModel !== null && defaultModel !== void 0 ? defaultModel : [], model, (vals) => {
+        if (onModelChange) {
+            onModelChange(vals, vals.map((val) => list.find((o) => o.value === val)));
+        }
+    }, undefined, formControl === null || formControl === void 0 ? void 0 : formControl.control);
+    const { disabled } = useScopedProps({ disabled: disabledProp || (formControl === null || formControl === void 0 ? void 0 : formControl.control.disabled) });
+    const childrenNode = children(list.map((option) => (_jsx(Checkbox, { model: values.includes(option.value), disabled: option.disabled || disabled, inputRender: (el) => cloneElement(el, formControl === null || formControl === void 0 ? void 0 : formControl.inputAria), onModelChange: (checked) => {
+            changeValues((draft) => {
+                if (checked) {
+                    draft.push(option.value);
+                }
+                else {
+                    draft.splice(draft.findIndex((v) => v === option.value), 1);
+                }
+            });
+        }, children: option.label }, option.value))));
+    return cloneElement(childrenNode, { role: (_a = childrenNode.props.role) !== null && _a !== void 0 ? _a : 'group' });
+}

package/checkbox/index.d.ts

@@ -0,0 +1,2 @@
+export type { CheckboxProps, CheckboxGroupProps } from './types';
+export { Checkbox } from './Checkbox';

package/checkbox/index.js

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

package/checkbox/types.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="react" />
+import type { CLASSES } from './vars';
+import type { FormControlProvider } from '../form/types';
+import type { BaseProps, CloneHTMLElement } from '../types';
+export {};
+export interface CheckboxProps extends BaseProps<'checkbox', typeof CLASSES>, React.LabelHTMLAttributes<HTMLLabelElement> {
+    formControl?: FormControlProvider;
+    model?: boolean;
+    defaultModel?: boolean;
+    indeterminate?: boolean;
+    disabled?: boolean;
+    inputRef?: React.ForwardedRef<HTMLInputElement>;
+    inputRender?: CloneHTMLElement;
+    onModelChange?: (checked: boolean) => void;
+}
+export interface CheckboxGroupItem<V extends React.Key> {
+    label: React.ReactNode;
+    value: V;
+    disabled?: boolean;
+}
+export interface CheckboxGroupProps<V extends React.Key, T extends CheckboxGroupItem<V>> {
+    children: (nodes: React.ReactElement[]) => React.ReactElement;
+    formControl?: FormControlProvider;
+    list: T[];
+    model?: V[];
+    defaultModel?: V[];
+    disabled?: boolean;
+    onModelChange?: (values: V[], origins: T[]) => void;
+}

package/checkbox/types.js

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

package/checkbox/vars.d.ts

@@ -0,0 +1,11 @@
+export declare const CLASSES: {
+    checkbox: string;
+    'checkbox.is-checked': string;
+    'checkbox.is-indeterminate': string;
+    'checkbox.is-disabled': string;
+    'checkbox__state-container': string;
+    checkbox__input: string;
+    checkbox__indeterminate: string;
+    checkbox__tick: string;
+    checkbox__label: string;
+};

package/checkbox/vars.js

@@ -0,0 +1,11 @@
+export const CLASSES = {
+    checkbox: '^checkbox',
+    'checkbox.is-checked': 'is-checked',
+    'checkbox.is-indeterminate': 'is-indeterminate',
+    'checkbox.is-disabled': 'is-disabled',
+    'checkbox__state-container': '^checkbox__state-container',
+    checkbox__input: '^checkbox__input',
+    checkbox__indeterminate: '^checkbox__indeterminate',
+    checkbox__tick: '^checkbox__tick',
+    checkbox__label: '^checkbox__label',
+};

package/compose/Compose.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { ComposeProps } from './types';
+import { ComposeItem } from './ComposeItem';
+export declare const Compose: {
+    (props: ComposeProps): JSX.Element | null;
+    Item: typeof ComposeItem;
+};

package/compose/Compose.js

@@ -0,0 +1,24 @@
+import { __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { ComposeItem } from './ComposeItem';
+import { CLASSES } from './vars';
+import { ConfigProvider } from '../config-provider';
+import { useComponentProps, useScopedProps, useStyled } from '../hooks';
+import { mergeCS } from '../utils';
+export const Compose = (props) => {
+    const _a = useComponentProps('Compose', props), { children, styleOverrides, styleProvider, size: sizeProp, vertical = false, disabled: disabledProp = false } = _a, restProps = __rest(_a, ["children", "styleOverrides", "styleProvider", "size", "vertical", "disabled"]);
+    const styled = useStyled(CLASSES, { compose: styleProvider === null || styleProvider === void 0 ? void 0 : styleProvider.compose }, styleOverrides);
+    const { size, disabled } = useScopedProps({ size: sizeProp, disabled: disabledProp });
+    const lContext = useMemo(() => ({
+        componentSize: size,
+        componentDisabled: disabled,
+    }), [disabled, size]);
+    return (_jsx("div", Object.assign({}, restProps, mergeCS(styled('compose', {
+        'compose--vertical': vertical,
+    }), {
+        className: restProps.className,
+        style: restProps.style,
+    }), { children: _jsx(ConfigProvider, { context: lContext, children: children }) })));
+};
+Compose.Item = ComposeItem;

package/compose/ComposeItem.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { ComposeItemProps } from './types';
+export declare function ComposeItem(props: ComposeItemProps): JSX.Element | null;

package/compose/ComposeItem.js

@@ -0,0 +1,18 @@
+import { __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CLASSES } from './vars';
+import { useComponentProps, useDesign, useScopedProps, useStyled } from '../hooks';
+import { mergeCS } from '../utils';
+export function ComposeItem(props) {
+    const _a = useComponentProps('ComposeItem', props), { children, styleOverrides, styleProvider, gray = false } = _a, restProps = __rest(_a, ["children", "styleOverrides", "styleProvider", "gray"]);
+    const styled = useStyled(CLASSES, { compose: styleProvider === null || styleProvider === void 0 ? void 0 : styleProvider.compose }, styleOverrides);
+    const { size, disabled } = useScopedProps({});
+    const designProps = useDesign({ compose: { disabled } });
+    return (_jsx("div", Object.assign({}, restProps, mergeCS(styled('compose__item', `compose__item--${size}`, {
+        'compose__item--gray': gray,
+        'compose__item.is-disabled': disabled,
+    }), {
+        className: restProps.className,
+        style: restProps.style,
+    }), designProps, { children: children })));
+}

package/compose/index.d.ts

@@ -0,0 +1,2 @@
+export type { ComposeProps, ComposeItemProps } from './types';
+export { Compose } from './Compose';

package/compose/index.js

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

package/compose/types.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { CLASSES } from './vars';
+import type { BaseProps, Size } from '../types';
+export {};
+export interface ComposeProps extends BaseProps<'compose', typeof CLASSES>, React.HTMLAttributes<HTMLDivElement> {
+    size?: Size;
+    vertical?: boolean;
+    disabled?: boolean;
+}
+export interface ComposeItemProps extends BaseProps<'compose', typeof CLASSES>, React.HTMLAttributes<HTMLDivElement> {
+    gray?: boolean;
+}

package/compose/types.js

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

package/compose/vars.d.ts

@@ -0,0 +1,10 @@
+export declare const CLASSES: {
+    compose: string;
+    'compose--vertical': string;
+    compose__item: string;
+    'compose__item--gray': string;
+    'compose__item--small': string;
+    'compose__item--medium': string;
+    'compose__item--large': string;
+    'compose__item.is-disabled': string;
+};

package/compose/vars.js

@@ -0,0 +1,10 @@
+export const CLASSES = {
+    compose: '^compose',
+    'compose--vertical': '^compose--vertical',
+    compose__item: '^compose__item',
+    'compose__item--gray': '^compose__item--gray',
+    'compose__item--small': '^compose__item--small',
+    'compose__item--medium': '^compose__item--medium',
+    'compose__item--large': '^compose__item--large',
+    'compose__item.is-disabled': 'is-disabled',
+};

package/config-provider/ConfigProvider.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { ConfigProviderProps } from './types';
+export declare function ConfigProvider(props: ConfigProviderProps): JSX.Element | null;

package/config-provider/ConfigProvider.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useContext, useMemo } from 'react';
+import { LContextManager } from '../context';
+import { LContext } from '../context';
+export function ConfigProvider(props) {
+    const { children, context: contextProp } = props;
+    const parent = useContext(LContext);
+    const context = useMemo(() => {
+        const context = new LContextManager(parent.derive(contextProp !== null && contextProp !== void 0 ? contextProp : {}));
+        context.setParent(parent);
+        return context;
+    }, [contextProp, parent]);
+    return _jsx(LContext.Provider, { value: context, children: children });
+}

package/config-provider/index.d.ts

@@ -0,0 +1,2 @@
+export type { ConfigProviderProps } from './types';
+export { ConfigProvider } from './ConfigProvider';

package/config-provider/index.js

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

package/config-provider/types.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { LContextIn } from '../context';
+export {};
+export interface ConfigProviderProps {
+    children?: React.ReactNode;
+    context?: LContextIn;
+}

package/config-provider/types.js

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

package/context/index.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="react" />
+import type { ComponentProps } from './props';
+import type { Size } from '../types';
+import type { RefExtra } from '@laser-ui/hooks/useRefExtra';
+interface LContextData {
+    namespace: string;
+    componentDisabled: boolean;
+    componentSize: Size;
+    componentDefaultProps: {
+        [K in keyof ComponentProps]?: Partial<ComponentProps[K]>;
+    };
+    layoutPageScrollEl: RefExtra | null;
+    layoutContentResizeEl: RefExtra | null;
+    listenGlobalScrolling: boolean;
+}
+export type LContextIn = Partial<LContextData>;
+export declare class LContextManager {
+    namespace: LContextData['namespace'];
+    componentDisabled: LContextData['componentDisabled'];
+    componentSize: LContextData['componentSize'];
+    componentDefaultProps: LContextData['componentDefaultProps'];
+    layoutPageScrollEl: LContextData['layoutPageScrollEl'];
+    layoutContentResizeEl: LContextData['layoutContentResizeEl'];
+    listenGlobalScrolling: LContextData['listenGlobalScrolling'];
+    private _parent;
+    get parent(): LContextManager | null;
+    get root(): LContextManager;
+    constructor(context: LContextData);
+    setParent(parent: LContextManager): void;
+    derive(context: LContextIn): LContextData;
+}
+export declare const LContext: import("react").Context<LContextManager>;
+export {};