@talex-touch/tuffex 0.3.3

package/dist/es/splitter/index.d.ts

@@ -0,0 +1,161 @@
+import { SplitterEmits, SplitterProps } from './src/types';
+import { default as TxSplitter } from './src/TxSplitter.vue';
+
+declare const Splitter: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        disabled: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        max: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+        modelValue: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+        min: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+        direction: {
+            type: import('vue').PropType<import('./src/types').SplitterDirection>;
+            default: string;
+        };
+        barSize: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+        snap: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+    }>> & Readonly<{
+        onChange?: ((v: number) => any) | undefined;
+        "onUpdate:modelValue"?: ((v: number) => any) | undefined;
+        "onDrag-start"?: (() => any) | undefined;
+        "onDrag-end"?: (() => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:modelValue": (v: number) => void;
+        change: (v: number) => void;
+        "drag-start": () => void;
+        "drag-end": () => void;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+        max: number;
+        modelValue: number;
+        min: number;
+        direction: import('./src/types').SplitterDirection;
+        barSize: number;
+        snap: number;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        disabled: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        max: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+        modelValue: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+        min: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+        direction: {
+            type: import('vue').PropType<import('./src/types').SplitterDirection>;
+            default: string;
+        };
+        barSize: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+        snap: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+    }>> & Readonly<{
+        onChange?: ((v: number) => any) | undefined;
+        "onUpdate:modelValue"?: ((v: number) => any) | undefined;
+        "onDrag-start"?: (() => any) | undefined;
+        "onDrag-end"?: (() => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        disabled: boolean;
+        max: number;
+        modelValue: number;
+        min: number;
+        direction: import('./src/types').SplitterDirection;
+        barSize: number;
+        snap: number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    disabled: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
+    max: {
+        type: import('vue').PropType<number>;
+        default: number;
+    };
+    modelValue: {
+        type: import('vue').PropType<number>;
+        default: number;
+    };
+    min: {
+        type: import('vue').PropType<number>;
+        default: number;
+    };
+    direction: {
+        type: import('vue').PropType<import('./src/types').SplitterDirection>;
+        default: string;
+    };
+    barSize: {
+        type: import('vue').PropType<number>;
+        default: number;
+    };
+    snap: {
+        type: import('vue').PropType<number>;
+        default: number;
+    };
+}>> & Readonly<{
+    onChange?: ((v: number) => any) | undefined;
+    "onUpdate:modelValue"?: ((v: number) => any) | undefined;
+    "onDrag-start"?: (() => any) | undefined;
+    "onDrag-end"?: (() => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (v: number) => void;
+    change: (v: number) => void;
+    "drag-start": () => void;
+    "drag-end": () => void;
+}, string, {
+    disabled: boolean;
+    max: number;
+    modelValue: number;
+    min: number;
+    direction: import('./src/types').SplitterDirection;
+    barSize: number;
+    snap: number;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        a?(_: {}): any;
+        b?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export { Splitter, TxSplitter };
+export type { SplitterEmits, SplitterProps };
+export type TxSplitterInstance = InstanceType<typeof TxSplitter>;
+export default Splitter;

package/dist/es/splitter/index.js

@@ -0,0 +1,6 @@
+import { withInstall } from '../utils/withInstall.js';
+import TxSplitter from './src/TxSplitter.vue.js';
+
+const Splitter = withInstall(TxSplitter);
+
+export { Splitter, TxSplitter, Splitter as default };

package/dist/es/splitter/src/TxSplitter.vue.d.ts

@@ -0,0 +1,65 @@
+import { SplitterDirection, SplitterProps } from './types';
+
+declare function __VLS_template(): {
+    a?(_: {}): any;
+    b?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SplitterProps>, {
+    modelValue: number;
+    direction: string;
+    min: number;
+    max: number;
+    disabled: boolean;
+    barSize: number;
+    snap: number;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (v: number) => void;
+    change: (v: number) => void;
+    "drag-start": () => void;
+    "drag-end": () => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SplitterProps>, {
+    modelValue: number;
+    direction: string;
+    min: number;
+    max: number;
+    disabled: boolean;
+    barSize: number;
+    snap: number;
+}>>> & Readonly<{
+    onChange?: ((v: number) => any) | undefined;
+    "onUpdate:modelValue"?: ((v: number) => any) | undefined;
+    "onDrag-start"?: (() => any) | undefined;
+    "onDrag-end"?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    max: number;
+    modelValue: number;
+    min: number;
+    direction: SplitterDirection;
+    barSize: number;
+    snap: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/splitter/src/TxSplitter.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from './TxSplitter.vue2.js';
+/* empty css                */
+import _export_sfc from '../../_virtual/_plugin-vue_export-helper.js';
+
+const TxSplitter = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-926e7b9d"]]);
+
+export { TxSplitter as default };

package/dist/es/splitter/src/TxSplitter.vue2.js

@@ -0,0 +1,159 @@
+import { defineComponent, ref, computed, watch, onBeforeUnmount, createElementBlock, openBlock, normalizeStyle, normalizeClass, createElementVNode, renderSlot } from 'vue';
+
+const _hoisted_1 = { class: "tx-splitter__pane tx-splitter__pane--a" };
+const _hoisted_2 = ["tabindex", "aria-orientation"];
+const _hoisted_3 = { class: "tx-splitter__pane tx-splitter__pane--b" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "TxSplitter" },
+  __name: "TxSplitter",
+  props: {
+    modelValue: { default: 0.5 },
+    direction: { default: "horizontal" },
+    min: { default: 0.1 },
+    max: { default: 0.9 },
+    disabled: { type: Boolean, default: false },
+    barSize: { default: 10 },
+    snap: { default: 0 }
+  },
+  emits: ["update:modelValue", "change", "drag-start", "drag-end"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const rootRef = ref(null);
+    const dragging = ref(false);
+    function clamp01(v) {
+      return Math.min(1, Math.max(0, v));
+    }
+    function clamp(v, min, max) {
+      return Math.min(max, Math.max(min, v));
+    }
+    function snapValue(v) {
+      const s = Math.max(0, props.snap ?? 0);
+      if (!s)
+        return v;
+      const n = Math.round(v / s) * s;
+      return clamp01(n);
+    }
+    const value = computed({
+      get: () => clamp01(Number.isFinite(props.modelValue) ? props.modelValue : 0.5),
+      set: (v) => {
+        const next = snapValue(clamp(v, props.min ?? 0.1, props.max ?? 0.9));
+        emit("update:modelValue", next);
+        emit("change", next);
+      }
+    });
+    const dir = computed(() => props.direction === "vertical" ? "vertical" : "horizontal");
+    const rootStyle = computed(() => {
+      return {
+        "--tx-splitter-bar-size": `${Math.max(6, props.barSize ?? 10)}px`,
+        "--tx-splitter-ratio": String(value.value)
+      };
+    });
+    function setByPointer(e) {
+      const el = rootRef.value;
+      if (!el)
+        return;
+      const rect = el.getBoundingClientRect();
+      if (dir.value === "horizontal") {
+        const x = e.clientX - rect.left;
+        const r2 = rect.width > 0 ? x / rect.width : 0.5;
+        value.value = r2;
+        return;
+      }
+      const y = e.clientY - rect.top;
+      const r = rect.height > 0 ? y / rect.height : 0.5;
+      value.value = r;
+    }
+    function onPointerDown(e) {
+      if (props.disabled)
+        return;
+      dragging.value = true;
+      emit("drag-start");
+      e.currentTarget?.setPointerCapture?.(e.pointerId);
+      setByPointer(e);
+      window.addEventListener("pointermove", onWindowPointerMove);
+      window.addEventListener("pointerup", onWindowPointerUp);
+    }
+    function onWindowPointerMove(e) {
+      if (!dragging.value)
+        return;
+      setByPointer(e);
+    }
+    function endDrag() {
+      if (!dragging.value)
+        return;
+      dragging.value = false;
+      emit("drag-end");
+      window.removeEventListener("pointermove", onWindowPointerMove);
+      window.removeEventListener("pointerup", onWindowPointerUp);
+    }
+    function onWindowPointerUp() {
+      endDrag();
+    }
+    function onKeyDown(e) {
+      if (props.disabled)
+        return;
+      const step = 0.02;
+      if (dir.value === "horizontal") {
+        if (e.key === "ArrowLeft") {
+          e.preventDefault();
+          value.value = value.value - step;
+        }
+        if (e.key === "ArrowRight") {
+          e.preventDefault();
+          value.value = value.value + step;
+        }
+      } else {
+        if (e.key === "ArrowUp") {
+          e.preventDefault();
+          value.value = value.value - step;
+        }
+        if (e.key === "ArrowDown") {
+          e.preventDefault();
+          value.value = value.value + step;
+        }
+      }
+    }
+    watch(
+      () => props.disabled,
+      (v) => {
+        if (v)
+          endDrag();
+      }
+    );
+    onBeforeUnmount(() => {
+      endDrag();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "rootRef",
+        ref: rootRef,
+        class: normalizeClass(["tx-splitter", [`is-${dir.value}`, { "is-disabled": __props.disabled, "is-dragging": dragging.value }]]),
+        style: normalizeStyle(rootStyle.value)
+      }, [
+        createElementVNode("div", _hoisted_1, [
+          renderSlot(_ctx.$slots, "a", {}, void 0, true)
+        ]),
+        createElementVNode("div", {
+          class: "tx-splitter__bar",
+          tabindex: __props.disabled ? -1 : 0,
+          role: "separator",
+          "aria-orientation": dir.value === "horizontal" ? "vertical" : "horizontal",
+          "aria-label": "Resize",
+          onPointerdown: onPointerDown,
+          onKeydown: onKeyDown
+        }, [..._cache[0] || (_cache[0] = [
+          createElementVNode("div", {
+            class: "tx-splitter__grip",
+            "aria-hidden": "true"
+          }, null, -1)
+        ])], 40, _hoisted_2),
+        createElementVNode("div", _hoisted_3, [
+          renderSlot(_ctx.$slots, "b", {}, void 0, true)
+        ])
+      ], 6);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/splitter/src/types.d.ts

@@ -0,0 +1,16 @@
+export type SplitterDirection = 'horizontal' | 'vertical';
+export interface SplitterProps {
+    modelValue?: number;
+    direction?: SplitterDirection;
+    min?: number;
+    max?: number;
+    disabled?: boolean;
+    barSize?: number;
+    snap?: number;
+}
+export interface SplitterEmits {
+    (e: 'update:modelValue', v: number): void;
+    (e: 'change', v: number): void;
+    (e: 'drag-start'): void;
+    (e: 'drag-end'): void;
+}

package/dist/es/stack/index.d.ts

@@ -0,0 +1,120 @@
+import { StackProps } from './src/types';
+import { default as TxStack } from './src/TxStack.vue';
+
+declare const Stack: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        inline: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        align: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        gap: {
+            type: import('vue').PropType<string | number>;
+            default: number;
+        };
+        justify: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        wrap: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        direction: {
+            type: import('vue').PropType<import('./src/types').StackDirection>;
+            default: string;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        inline: boolean;
+        align: string;
+        gap: number | string;
+        justify: string;
+        wrap: boolean;
+        direction: import('./src/types').StackDirection;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        inline: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        align: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        gap: {
+            type: import('vue').PropType<string | number>;
+            default: number;
+        };
+        justify: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        wrap: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        direction: {
+            type: import('vue').PropType<import('./src/types').StackDirection>;
+            default: string;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, {
+        inline: boolean;
+        align: string;
+        gap: number | string;
+        justify: string;
+        wrap: boolean;
+        direction: import('./src/types').StackDirection;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    inline: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
+    align: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    gap: {
+        type: import('vue').PropType<string | number>;
+        default: number;
+    };
+    justify: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    wrap: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
+    direction: {
+        type: import('vue').PropType<import('./src/types').StackDirection>;
+        default: string;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    inline: boolean;
+    align: string;
+    gap: number | string;
+    justify: string;
+    wrap: boolean;
+    direction: import('./src/types').StackDirection;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export { Stack, TxStack };
+export type { StackProps };
+export type TxStackInstance = InstanceType<typeof TxStack>;
+export default Stack;

package/dist/es/stack/index.js

@@ -0,0 +1,6 @@
+import { withInstall } from '../utils/withInstall.js';
+import TxStack from './src/TxStack.vue.js';
+
+const Stack = withInstall(TxStack);
+
+export { Stack, TxStack, Stack as default };

package/dist/es/stack/src/TxStack.vue.d.ts

@@ -0,0 +1,51 @@
+import { StackProps } from './types';
+
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StackProps>, {
+    direction: string;
+    gap: number;
+    align: string;
+    justify: string;
+    wrap: boolean;
+    inline: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StackProps>, {
+    direction: string;
+    gap: number;
+    align: string;
+    justify: string;
+    wrap: boolean;
+    inline: boolean;
+}>>> & Readonly<{}>, {
+    inline: boolean;
+    align: string;
+    gap: number | string;
+    justify: string;
+    wrap: boolean;
+    direction: import('./types').StackDirection;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/stack/src/TxStack.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from './TxStack.vue2.js';
+/* empty css             */
+import _export_sfc from '../../_virtual/_plugin-vue_export-helper.js';
+
+const TxStack = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-070094ba"]]);
+
+export { TxStack as default };

package/dist/es/stack/src/TxStack.vue2.js

@@ -0,0 +1,38 @@
+import { defineComponent, computed, createElementBlock, openBlock, normalizeStyle, renderSlot } from 'vue';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "TxStack" },
+  __name: "TxStack",
+  props: {
+    direction: { default: "vertical" },
+    gap: { default: 12 },
+    align: { default: "stretch" },
+    justify: { default: "flex-start" },
+    wrap: { type: Boolean, default: false },
+    inline: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const style = computed(() => {
+      const gap = typeof props.gap === "number" ? `${props.gap}px` : String(props.gap);
+      return {
+        "--tx-stack-gap": gap,
+        "--tx-stack-align": props.align || "stretch",
+        "--tx-stack-justify": props.justify || "flex-start",
+        "--tx-stack-direction": props.direction === "horizontal" ? "row" : "column",
+        "--tx-stack-wrap": props.wrap ? "wrap" : "nowrap",
+        "--tx-stack-display": props.inline ? "inline-flex" : "flex"
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "tx-stack",
+        style: normalizeStyle(style.value)
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 4);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/stack/src/types.d.ts

@@ -0,0 +1,9 @@
+export type StackDirection = 'horizontal' | 'vertical';
+export interface StackProps {
+    direction?: StackDirection;
+    gap?: number | string;
+    align?: string;
+    justify?: string;
+    wrap?: boolean;
+    inline?: boolean;
+}