@type-dom/ui 0.1.0 → 0.1.1

package/src/components/others/td-watermark/td-watermark.class.d.ts

@@ -0,0 +1,8 @@
+import { TypeDiv } from '@type-dom/framework';
+import { ITdWatermark, WatermarkProps } from './td-watermark.interface';
+export declare class TdWatermark extends TypeDiv implements ITdWatermark {
+    className: 'TdWatermark';
+    props: WatermarkProps;
+    constructor(params?: WatermarkProps);
+    setup(): void;
+}

package/src/components/others/td-watermark/td-watermark.class.js

@@ -1 +1,193 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TdWatermark = void 0;
+const framework_1 = require("@type-dom/framework");
+const td_watermark_const_1 = require("./td-watermark.const");
+const utils_1 = require("./utils");
+const signals_1 = require("@type-dom/signals");
+const useClips_1 = require("./useClips");
+const utils_2 = require("@type-dom/utils");
+class TdWatermark extends framework_1.TypeDiv {
+    constructor(params = {}) {
+        super();
+        this.className = 'TdWatermark';
+        this.assignProps(td_watermark_const_1.watermarkProps);
+        this.props = this.useParams(params);
+    }
+    setup() {
+        const style = {
+            position: 'relative',
+        };
+        const props = this.props;
+        const color = (0, signals_1.computed)(() => { var _a, _b; return (_b = (_a = props.font) === null || _a === void 0 ? void 0 : _a.color) !== null && _b !== void 0 ? _b : 'rgba(0,0,0,.15)'; });
+        const fontSize = (0, signals_1.computed)(() => { var _a, _b; return (_b = (_a = props.font) === null || _a === void 0 ? void 0 : _a.fontSize) !== null && _b !== void 0 ? _b : 16; });
+        const fontWeight = (0, signals_1.computed)(() => { var _a, _b; return (_b = (_a = props.font) === null || _a === void 0 ? void 0 : _a.fontWeight) !== null && _b !== void 0 ? _b : 'normal'; });
+        const fontStyle = (0, signals_1.computed)(() => { var _a, _b; return (_b = (_a = props.font) === null || _a === void 0 ? void 0 : _a.fontStyle) !== null && _b !== void 0 ? _b : 'normal'; });
+        const fontFamily = (0, signals_1.computed)(() => { var _a, _b; return (_b = (_a = props.font) === null || _a === void 0 ? void 0 : _a.fontFamily) !== null && _b !== void 0 ? _b : 'sans-serif'; });
+        const textAlign = (0, signals_1.computed)(() => { var _a, _b; return (_b = (_a = props.font) === null || _a === void 0 ? void 0 : _a.textAlign) !== null && _b !== void 0 ? _b : 'center'; });
+        const textBaseline = (0, signals_1.computed)(() => { var _a, _b; return (_b = (_a = props.font) === null || _a === void 0 ? void 0 : _a.textBaseline) !== null && _b !== void 0 ? _b : 'hanging'; });
+        const gapX = (0, signals_1.computed)(() => { var _a; return (_a = props.gap) === null || _a === void 0 ? void 0 : _a[0]; });
+        const gapY = (0, signals_1.computed)(() => { var _a; return (_a = props.gap) === null || _a === void 0 ? void 0 : _a[1]; });
+        const gapXCenter = (0, signals_1.computed)(() => gapX.get() / 2);
+        const gapYCenter = (0, signals_1.computed)(() => gapY.get() / 2);
+        const offsetLeft = (0, signals_1.computed)(() => { var _a, _b; return (_b = (_a = props.offset) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : gapXCenter.get(); });
+        const offsetTop = (0, signals_1.computed)(() => { var _a, _b; return (_b = (_a = props.offset) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : gapYCenter.get(); });
+        const getMarkStyle = () => {
+            const markStyle = {
+                zIndex: props.zIndex,
+                position: 'absolute',
+                left: 0,
+                top: 0,
+                width: '100%',
+                height: '100%',
+                pointerEvents: 'none',
+                backgroundRepeat: 'repeat',
+            };
+            /** Calculate the style of the offset */
+            let positionLeft = offsetLeft.get() - gapXCenter.get();
+            let positionTop = offsetTop.get() - gapYCenter.get();
+            if (positionLeft > 0) {
+                markStyle.left = `${positionLeft}px`;
+                markStyle.width = `calc(100% - ${positionLeft}px)`;
+                positionLeft = 0;
+            }
+            if (positionTop > 0) {
+                markStyle.top = `${positionTop}px`;
+                markStyle.height = `calc(100% - ${positionTop}px)`;
+                positionTop = 0;
+            }
+            markStyle.backgroundPosition = `${positionLeft}px ${positionTop}px`;
+            return markStyle;
+        };
+        const containerRef = (0, signals_1.signal)(undefined);
+        const watermarkRef = (0, signals_1.signal)();
+        const stopObservation = (0, signals_1.signal)(false);
+        const destroyWatermark = () => {
+            var _a;
+            if (watermarkRef.get()) {
+                (_a = watermarkRef.get()) === null || _a === void 0 ? void 0 : _a.remove();
+                watermarkRef.set(undefined);
+            }
+        };
+        const appendWatermark = (base64Url, markWidth) => {
+            var _a, _b;
+            if (containerRef.get() && watermarkRef.get()) {
+                stopObservation.set(true);
+                (_a = watermarkRef.get()) === null || _a === void 0 ? void 0 : _a.setAttribute('style', (0, utils_1.getStyleStr)(Object.assign(Object.assign({}, getMarkStyle()), { backgroundImage: `url('${base64Url}')`, backgroundSize: `${Math.floor(markWidth)}px` })));
+                (_b = containerRef.get()) === null || _b === void 0 ? void 0 : _b.append(watermarkRef.get());
+                // Delayed execution
+                setTimeout(() => {
+                    stopObservation.set(false);
+                });
+            }
+        };
+        /**
+         * Get the width and height of the watermark. The default values are as follows
+         * Image: [120, 64]; Content: It's calculated by content;
+         */
+        const getMarkSize = (ctx) => {
+            let defaultWidth = 120;
+            let defaultHeight = 64;
+            const image = props.image;
+            const content = props.content;
+            const width = props.width;
+            const height = props.height;
+            if (!image && ctx.measureText) {
+                ctx.font = `${Number(fontSize.get())}px ${fontFamily.get()}`;
+                const contents = (0, utils_2.isArray)(content) ? content : [content];
+                const sizes = contents.map((item) => {
+                    const metrics = ctx.measureText(item);
+                    return [
+                        metrics.width,
+                        // Using `actualBoundingBoxAscent` to be compatible with lower version browsers (eg: Firefox < 116)
+                        metrics.fontBoundingBoxAscent !== undefined
+                            ? metrics.fontBoundingBoxAscent + metrics.fontBoundingBoxDescent
+                            : metrics.actualBoundingBoxAscent +
+                                metrics.actualBoundingBoxDescent,
+                    ];
+                });
+                defaultWidth = Math.ceil(Math.max(...sizes.map((size) => size[0])));
+                defaultHeight =
+                    Math.ceil(Math.max(...sizes.map((size) => size[1]))) *
+                        contents.length +
+                        (contents.length - 1) * useClips_1.FontGap;
+            }
+            return [width !== null && width !== void 0 ? width : defaultWidth, height !== null && height !== void 0 ? height : defaultHeight];
+        };
+        const getClips = (0, useClips_1.default)();
+        const renderWatermark = () => {
+            const canvas = document.createElement('canvas');
+            const ctx = canvas.getContext('2d');
+            const image = props.image;
+            const content = props.content;
+            const rotate = props.rotate;
+            if (ctx) {
+                if (!watermarkRef.get()) {
+                    watermarkRef.set(document.createElement('div'));
+                }
+                const ratio = (0, utils_1.getPixelRatio)();
+                const [markWidth, markHeight] = getMarkSize(ctx);
+                const drawCanvas = (drawContent) => {
+                    const [textClips, clipWidth] = getClips(drawContent || '', rotate, ratio, markWidth, markHeight, {
+                        color: color.get(),
+                        fontSize: fontSize.get(),
+                        fontStyle: fontStyle.get(),
+                        fontWeight: fontWeight.get(),
+                        fontFamily: fontFamily.get(),
+                        textAlign: textAlign.get(),
+                        textBaseline: textBaseline.get(),
+                    }, gapX.get(), gapY.get());
+                    appendWatermark(textClips, clipWidth);
+                };
+                if (image) {
+                    const img = new Image();
+                    img.onload = () => {
+                        drawCanvas(img);
+                    };
+                    img.onerror = () => {
+                        drawCanvas(content);
+                    };
+                    img.crossOrigin = 'anonymous';
+                    img.referrerPolicy = 'no-referrer';
+                    img.src = image;
+                }
+                else {
+                    drawCanvas(content);
+                }
+            }
+        };
+        (0, framework_1.onMounted)(() => {
+            renderWatermark();
+        });
+        (0, signals_1.watch)(() => props, () => {
+            renderWatermark();
+        }, {
+            deep: true,
+            flush: 'post',
+        });
+        (0, framework_1.onBeforeUnmount)(() => {
+            destroyWatermark();
+        });
+        const onMutate = (mutations) => {
+            if (stopObservation.get()) {
+                return;
+            }
+            mutations.forEach((mutation) => {
+                if ((0, utils_1.reRendering)(mutation, watermarkRef.get())) {
+                    destroyWatermark();
+                    renderWatermark();
+                }
+            });
+        };
+        (0, framework_1.useMutationObserver)(containerRef, onMutate, {
+            attributes: true,
+            subtree: true,
+            childList: true,
+        });
+        this.assignProps({
+            refDom: containerRef,
+        });
+        this.style.addObj(style);
+    }
+}
+exports.TdWatermark = TdWatermark;

package/src/components/others/td-watermark/td-watermark.const.d.ts

@@ -0,0 +1,2 @@
+import { WatermarkProps } from './td-watermark.interface';
+export declare const watermarkProps: WatermarkProps;

package/src/components/others/td-watermark/td-watermark.const.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watermarkProps = void 0;
+exports.watermarkProps = {
+    zIndex: 9,
+    rotate: -22,
+    content: 'TypeDom UI',
+    gap: [100, 100],
+};

package/src/components/others/td-watermark/td-watermark.interface.d.ts

@@ -0,0 +1,52 @@
+import { ITypeDiv, TypeDivProps } from '@type-dom/framework';
+export interface ITdWatermark extends ITypeDiv {
+    className: 'TdWatermark';
+}
+export interface WatermarkFontType {
+    color?: string;
+    fontSize?: number | string;
+    fontWeight?: 'normal' | 'light' | 'weight' | number;
+    fontStyle?: 'none' | 'normal' | 'italic' | 'oblique';
+    fontFamily?: string;
+    textAlign?: 'start' | 'end' | 'left' | 'right' | 'center';
+    textBaseline?: 'top' | 'hanging' | 'middle' | 'alphabetic' | 'ideographic' | 'bottom';
+}
+export interface WatermarkProps extends TypeDivProps {
+    /**
+     * @description The z-index of the appended watermark element
+     *     default: 9,
+     */
+    zIndex?: number;
+    /**
+     * @description The rotation angle of the watermark
+     */
+    rotate?: number;
+    /**
+     * @description The width of the watermark
+     */
+    width?: number;
+    /**
+     * @description The height of the watermark
+     */
+    height?: number;
+    /**
+     * @description Image source, it is recommended to export 2x or 3x image, high priority (support base64 format)
+     */
+    image?: string;
+    /**
+     * @description Watermark text content
+     */
+    content?: string | string[];
+    /**
+     * @description Text style
+     */
+    font?: WatermarkFontType;
+    /**
+     * @description The spacing between watermarks
+     */
+    gap?: [number, number];
+    /**
+     * @description The offset of the watermark from the upper left corner of the container. The default is gap/2
+     */
+    offset?: [number, number];
+}

package/src/components/others/td-watermark/td-watermark.interface.js

@@ -1 +1,2 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/components/others/td-watermark/useClips.d.ts

@@ -0,0 +1,7 @@
+import type { WatermarkProps } from './td-watermark.interface';
+export declare const FontGap = 3;
+/**
+ * Get the clips of text content.
+ * This is a lazy hook function since SSR no need this
+ */
+export default function useClips(): (content: NonNullable<WatermarkProps["content"]> | HTMLImageElement, rotate: number, ratio: number, width: number, height: number, font: Required<NonNullable<WatermarkProps["font"]>>, gapX: number, gapY: number) => [dataURL: string, finalWidth: number, finalHeight: number];

package/src/components/others/td-watermark/useClips.js

@@ -0,0 +1,98 @@
+"use strict";
+// import { isArray } from '@element-plus/utils'
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FontGap = void 0;
+exports.default = useClips;
+const utils_1 = require("@type-dom/utils");
+exports.FontGap = 3;
+function prepareCanvas(width, height, ratio = 1) {
+    const canvas = document.createElement('canvas');
+    const ctx = canvas.getContext('2d');
+    const realWidth = width * ratio;
+    const realHeight = height * ratio;
+    canvas.setAttribute('width', `${realWidth}px`);
+    canvas.setAttribute('height', `${realHeight}px`);
+    ctx.save();
+    return [ctx, canvas, realWidth, realHeight];
+}
+/**
+ * Get the clips of text content.
+ * This is a lazy hook function since SSR no need this
+ */
+function useClips() {
+    // Get single clips
+    function getClips(content, rotate, ratio, width, height, font, gapX, gapY) {
+        // ================= Text / Image =================
+        const [ctx, canvas, contentWidth, contentHeight] = prepareCanvas(width, height, ratio);
+        if (content instanceof HTMLImageElement) {
+            // Image
+            ctx.drawImage(content, 0, 0, contentWidth, contentHeight);
+        }
+        else {
+            // Text
+            const { color, fontSize, fontStyle, fontWeight, fontFamily, textAlign, textBaseline, } = font;
+            const mergedFontSize = Number(fontSize) * ratio;
+            ctx.font = `${fontStyle} normal ${fontWeight} ${mergedFontSize}px/${height}px ${fontFamily}`;
+            ctx.fillStyle = color;
+            ctx.textAlign = textAlign;
+            ctx.textBaseline = textBaseline;
+            const contents = (0, utils_1.isArray)(content) ? content : [content];
+            contents === null || contents === void 0 ? void 0 : contents.forEach((item, index) => {
+                ctx.fillText(item !== null && item !== void 0 ? item : '', contentWidth / 2, index * (mergedFontSize + exports.FontGap * ratio));
+            });
+        }
+        // ==================== Rotate ====================
+        const angle = (Math.PI / 180) * Number(rotate);
+        const maxSize = Math.max(width, height);
+        const [rCtx, rCanvas, realMaxSize] = prepareCanvas(maxSize, maxSize, ratio);
+        // Copy from `ctx` and rotate
+        rCtx.translate(realMaxSize / 2, realMaxSize / 2);
+        rCtx.rotate(angle);
+        if (contentWidth > 0 && contentHeight > 0) {
+            rCtx.drawImage(canvas, -contentWidth / 2, -contentHeight / 2);
+        }
+        // Get boundary of rotated text
+        function getRotatePos(x, y) {
+            const targetX = x * Math.cos(angle) - y * Math.sin(angle);
+            const targetY = x * Math.sin(angle) + y * Math.cos(angle);
+            return [targetX, targetY];
+        }
+        let left = 0;
+        let right = 0;
+        let top = 0;
+        let bottom = 0;
+        const halfWidth = contentWidth / 2;
+        const halfHeight = contentHeight / 2;
+        const points = [
+            [0 - halfWidth, 0 - halfHeight],
+            [0 + halfWidth, 0 - halfHeight],
+            [0 + halfWidth, 0 + halfHeight],
+            [0 - halfWidth, 0 + halfHeight],
+        ];
+        points.forEach(([x, y]) => {
+            const [targetX, targetY] = getRotatePos(x, y);
+            left = Math.min(left, targetX);
+            right = Math.max(right, targetX);
+            top = Math.min(top, targetY);
+            bottom = Math.max(bottom, targetY);
+        });
+        const cutLeft = left + realMaxSize / 2;
+        const cutTop = top + realMaxSize / 2;
+        const cutWidth = right - left;
+        const cutHeight = bottom - top;
+        // ================ Fill Alternate ================
+        const realGapX = gapX * ratio;
+        const realGapY = gapY * ratio;
+        const filledWidth = (cutWidth + realGapX) * 2;
+        const filledHeight = cutHeight + realGapY;
+        const [fCtx, fCanvas] = prepareCanvas(filledWidth, filledHeight);
+        function drawImg(targetX = 0, targetY = 0) {
+            fCtx.drawImage(rCanvas, cutLeft, cutTop, cutWidth, cutHeight, targetX, targetY, cutWidth, cutHeight);
+        }
+        drawImg();
+        drawImg(cutWidth + realGapX, -cutHeight / 2 - realGapY / 2);
+        drawImg(cutWidth + realGapX, +cutHeight / 2 + realGapY / 2);
+        return [fCanvas.toDataURL(), filledWidth / ratio, filledHeight / ratio];
+    }
+    return getClips;
+}

package/src/components/others/td-watermark/utils.d.ts

@@ -0,0 +1,8 @@
+import { IStyle } from '@type-dom/css-type';
+/** converting camel-cased strings to be lowercase and link it with Separato */
+export declare function toLowercaseSeparator(key: string): string;
+export declare function getStyleStr(style: IStyle): string;
+/** Returns the ratio of the device's physical pixel resolution to the css pixel resolution */
+export declare function getPixelRatio(): number;
+/** Whether to re-render the watermark */
+export declare const reRendering: (mutation: MutationRecord, watermarkElement?: HTMLElement) => boolean;

package/src/components/others/td-watermark/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+// import type { CSSProperties } from 'vue'
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reRendering = void 0;
+exports.toLowercaseSeparator = toLowercaseSeparator;
+exports.getStyleStr = getStyleStr;
+exports.getPixelRatio = getPixelRatio;
+/** converting camel-cased strings to be lowercase and link it with Separato */
+function toLowercaseSeparator(key) {
+    return key.replace(/([A-Z])/g, '-$1').toLowerCase();
+}
+function getStyleStr(style) {
+    return Object.keys(style)
+        .map((key) => `${toLowercaseSeparator(key)}: ${style[key]};`)
+        .join(' ');
+}
+/** Returns the ratio of the device's physical pixel resolution to the css pixel resolution */
+function getPixelRatio() {
+    return window.devicePixelRatio || 1;
+}
+/** Whether to re-render the watermark */
+const reRendering = (mutation, watermarkElement) => {
+    let flag = false;
+    // Whether to delete the watermark node
+    if (mutation.removedNodes.length && watermarkElement) {
+        flag = Array.from(mutation.removedNodes).includes(watermarkElement);
+    }
+    // Whether the watermark dom property value has been modified
+    if (mutation.type === 'attributes' && mutation.target === watermarkElement) {
+        flag = true;
+    }
+    return flag;
+};
+exports.reRendering = reRendering;

package/src/constants/aria.d.ts

@@ -1,17 +1,35 @@
-export declare const ariaProps: {
+import { TypeProps } from '@type-dom/framework';
+export interface IAriaConfig extends TypeProps {
     /**
      * @description native `aria-label` attribute
      */
-    ariaLabel: StringConstructor;
+    ariaLabel?: string;
     /**
      * @description native `aria-orientation` attribute
      */
-    ariaOrientation: {
-        type: StringConstructor;
-        values: string[];
-    };
+    ariaOrientation?: 'horizontal' | 'vertical' | 'undefined';
     /**
      * @description native `aria-controls` attribute
      */
-    ariaControls: StringConstructor;
+    ariaControls?: string;
+    ariaDescribedby?: string;
+    ariaExpanded?: string;
+    ariaHaspopup?: string;
+}
+export declare const EVENT_CODE: {
+    tab: string;
+    enter: string;
+    space: string;
+    left: string;
+    up: string;
+    right: string;
+    down: string;
+    esc: string;
+    delete: string;
+    backspace: string;
+    numpadEnter: string;
+    pageUp: string;
+    pageDown: string;
+    home: string;
+    end: string;
 };

package/src/constants/aria.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ariaProps = void 0;
-exports.ariaProps = {
-    /**
-     * @description native `aria-label` attribute
-     */
-    ariaLabel: String,
-    /**
-     * @description native `aria-orientation` attribute
-     */
-    ariaOrientation: {
-        type: String,
-        values: ['horizontal', 'vertical', 'undefined'],
-    },
-    /**
-     * @description native `aria-controls` attribute
-     */
-    ariaControls: String,
+exports.EVENT_CODE = void 0;
+exports.EVENT_CODE = {
+    tab: 'Tab',
+    enter: 'Enter',
+    space: 'Space',
+    left: 'ArrowLeft', // 37
+    up: 'ArrowUp', // 38
+    right: 'ArrowRight', // 39
+    down: 'ArrowDown', // 40
+    esc: 'Escape',
+    delete: 'Delete',
+    backspace: 'Backspace',
+    numpadEnter: 'NumpadEnter',
+    pageUp: 'PageUp',
+    pageDown: 'PageDown',
+    home: 'Home',
+    end: 'End',
 };

package/src/constants/date.d.ts

@@ -0,0 +1,3 @@
+export declare const datePickTypes: readonly ["year", "years", "month", "months", "date", "dates", "week", "datetime", "datetimerange", "daterange", "monthrange", "yearrange"];
+export declare const WEEK_DAYS: readonly ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+export type DatePickType = (typeof datePickTypes)[number];

package/src/constants/date.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEEK_DAYS = exports.datePickTypes = void 0;
+exports.datePickTypes = [
+    'year',
+    'years',
+    'month',
+    'months',
+    'date',
+    'dates',
+    'week',
+    'datetime',
+    'datetimerange',
+    'daterange',
+    'monthrange',
+    'yearrange',
+];
+exports.WEEK_DAYS = [
+    'sun',
+    'mon',
+    'tue',
+    'wed',
+    'thu',
+    'fri',
+    'sat',
+];

package/src/constants/index.d.ts

@@ -0,0 +1,5 @@
+export * from './aria';
+export * from './date';
+export * from './event';
+export * from './key';
+export * from './size';

package/src/constants/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./aria"), exports);
+tslib_1.__exportStar(require("./date"), exports);
+tslib_1.__exportStar(require("./event"), exports);
+tslib_1.__exportStar(require("./key"), exports);
+tslib_1.__exportStar(require("./size"), exports);

package/src/constants/key.d.ts

@@ -0,0 +1 @@
+export declare const INSTALLED_KEY: unique symbol;

package/src/constants/key.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSTALLED_KEY = void 0;
+exports.INSTALLED_KEY = Symbol('INSTALLED_KEY');

package/src/constants/size.d.ts

@@ -0,0 +1,7 @@
+export declare const componentSizes: readonly ["", "default", "small", "large"];
+export type ComponentSize = (typeof componentSizes)[number];
+export declare const componentSizeMap: {
+    readonly large: 40;
+    readonly default: 32;
+    readonly small: 24;
+};

package/src/{styles → constants}/size.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.componentSizes = void 0;
+exports.componentSizeMap = exports.componentSizes = void 0;
 exports.componentSizes = ['', 'default', 'small', 'large'];
-const componentSizeMap = {
+exports.componentSizeMap = {
     large: 40,
     default: 32,
     small: 24,

package/src/hooks/index.d.ts

@@ -1,4 +1,31 @@
+export * from './use-aria';
+export * from './use-attrs';
+export * from './use-calc-input-width';
+export * from './use-composition';
 export * from './use-cursor';
+export * from './use-delayed-toggle';
+export * from './use-deprecated';
+export * from './use-draggable';
+export * from './use-empty-values';
 export * from './use-escape-keydown';
+export * from './use-floating';
+export * from './use-focus-controller';
 export * from './use-forward-ref';
-export * from './use-delayed-toggle';
+export * from './use-id';
+export * from './use-intermediate-render';
+export * from './use-locale';
+export * from './use-lockscreen';
+export * from './use-modal';
+export * from './use-model-toggle';
+export * from './use-namespace';
+export * from './use-ordered-children';
+export * from './use-popper';
+export * from './use-popper-container';
+export * from './use-prevent-global';
+export * from './use-prop';
+export * from './use-same-target';
+export * from './use-size';
+export * from './use-throttle-render';
+export * from './use-timeout';
+export * from './use-transition-fallthrough';
+export * from './use-z-index';

package/src/hooks/index.js

@@ -1,7 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./use-aria"), exports);
+tslib_1.__exportStar(require("./use-attrs"), exports);
+tslib_1.__exportStar(require("./use-calc-input-width"), exports);
+tslib_1.__exportStar(require("./use-composition"), exports);
 tslib_1.__exportStar(require("./use-cursor"), exports);
+tslib_1.__exportStar(require("./use-delayed-toggle"), exports);
+tslib_1.__exportStar(require("./use-deprecated"), exports);
+tslib_1.__exportStar(require("./use-draggable"), exports);
+tslib_1.__exportStar(require("./use-empty-values"), exports);
 tslib_1.__exportStar(require("./use-escape-keydown"), exports);
+tslib_1.__exportStar(require("./use-floating"), exports);
+tslib_1.__exportStar(require("./use-focus-controller"), exports);
 tslib_1.__exportStar(require("./use-forward-ref"), exports);
-tslib_1.__exportStar(require("./use-delayed-toggle"), exports);
+tslib_1.__exportStar(require("./use-id"), exports);
+tslib_1.__exportStar(require("./use-intermediate-render"), exports);
+tslib_1.__exportStar(require("./use-locale"), exports);
+tslib_1.__exportStar(require("./use-lockscreen"), exports);
+tslib_1.__exportStar(require("./use-modal"), exports);
+tslib_1.__exportStar(require("./use-model-toggle"), exports);
+tslib_1.__exportStar(require("./use-namespace"), exports);
+tslib_1.__exportStar(require("./use-ordered-children"), exports);
+tslib_1.__exportStar(require("./use-popper"), exports);
+tslib_1.__exportStar(require("./use-popper-container"), exports);
+tslib_1.__exportStar(require("./use-prevent-global"), exports);
+tslib_1.__exportStar(require("./use-prop"), exports);
+tslib_1.__exportStar(require("./use-same-target"), exports);
+tslib_1.__exportStar(require("./use-size"), exports);
+tslib_1.__exportStar(require("./use-throttle-render"), exports);
+tslib_1.__exportStar(require("./use-timeout"), exports);
+tslib_1.__exportStar(require("./use-transition-fallthrough"), exports);
+tslib_1.__exportStar(require("./use-z-index"), exports);