@talex-touch/tuffex 0.3.3

package/dist/es/status-badge/src/TxStatusBadge.vue.d.ts

@@ -0,0 +1,40 @@
+import { StatusBadgeProps, StatusTone } from './types';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StatusBadgeProps>, {
+    icon: string;
+    status: undefined;
+    statusKey: string;
+    size: string;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StatusBadgeProps>, {
+    icon: string;
+    status: undefined;
+    statusKey: string;
+    size: string;
+}>>> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    icon: string;
+    size: "sm" | "md";
+    status: StatusTone;
+    statusKey: import('./types').StatusKey;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+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];
+} & {};

package/dist/es/status-badge/src/TxStatusBadge.vue.js

@@ -0,0 +1,93 @@
+import { defineComponent, computed, createElementBlock, openBlock, normalizeStyle, normalizeClass, createCommentVNode, createElementVNode, toDisplayString } from 'vue';
+
+const _hoisted_1 = { class: "tx-status-badge__text" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "TxStatusBadge"
+  },
+  __name: "TxStatusBadge",
+  props: {
+    text: {},
+    icon: { default: "" },
+    status: { default: void 0 },
+    statusKey: { default: "" },
+    size: { default: "md" },
+    os: {},
+    osOnly: { type: Boolean }
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const toneMap = {
+      success: { color: "var(--tx-color-success)", icon: "i-carbon-checkmark-filled" },
+      warning: { color: "var(--tx-color-warning)", icon: "i-carbon-warning" },
+      danger: { color: "var(--tx-color-danger)", icon: "i-carbon-close-outline" },
+      info: { color: "var(--tx-color-primary)", icon: "i-carbon-information" },
+      muted: { color: "var(--tx-text-color-secondary)", icon: "i-carbon-minimize" }
+    };
+    const resolvedTone = computed(() => {
+      if (props.status)
+        return props.status;
+      switch (props.statusKey) {
+        case "granted":
+          return "success";
+        case "denied":
+          return "danger";
+        case "notDetermined":
+          return "warning";
+        case "unsupported":
+          return "muted";
+        default:
+          return "info";
+      }
+    });
+    const toneMeta = computed(() => toneMap[resolvedTone.value]);
+    const styleVars = computed(() => {
+      const color = toneMeta.value.color;
+      return {
+        "--tx-status-color": color,
+        "--tx-status-bg": `color-mix(in srgb, ${color} 12%, transparent)`,
+        "--tx-status-border": `color-mix(in srgb, ${color} 32%, transparent)`
+      };
+    });
+    const iconClass = computed(() => props.icon || toneMeta.value.icon);
+    const osIconClass = computed(() => {
+      switch (props.os) {
+        case "macos":
+          return "i-carbon-logo-apple";
+        case "windows":
+          return "i-carbon-logo-windows";
+        case "linux":
+          return "i-carbon-logo-tux";
+        default:
+          return "";
+      }
+    });
+    function handleClick(event) {
+      emit("click", event);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["tx-status-badge", [`tx-status-badge--${__props.size}`]]),
+        style: normalizeStyle(styleVars.value),
+        role: "status",
+        onClick: handleClick
+      }, [
+        osIconClass.value ? (openBlock(), createElementBlock("i", {
+          key: 0,
+          class: normalizeClass([osIconClass.value, "tx-status-badge__icon"]),
+          "aria-hidden": "true"
+        }, null, 2)) : createCommentVNode("", true),
+        !__props.osOnly && iconClass.value ? (openBlock(), createElementBlock("i", {
+          key: 1,
+          class: normalizeClass([iconClass.value, "tx-status-badge__icon"]),
+          "aria-hidden": "true"
+        }, null, 2)) : createCommentVNode("", true),
+        createElementVNode("span", _hoisted_1, toDisplayString(__props.text), 1)
+      ], 6);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/status-badge/src/TxStatusBadge.vue3.js

@@ -0,0 +1,6 @@
+import _sfc_main from './TxStatusBadge.vue.js';
+/* empty css                   */
+
+
+
+export { _sfc_main as default };

package/dist/es/status-badge/src/types.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Status tone types for visual styling.
+ *
+ * @public
+ */
+export type StatusTone = 'success' | 'warning' | 'danger' | 'info' | 'muted';
+/**
+ * Predefined status keys that map to status tones.
+ *
+ * @public
+ */
+export type StatusKey = 'granted' | 'denied' | 'notDetermined' | 'unsupported' | string;
+/**
+ * OS/platform identifiers.
+ *
+ * @public
+ */
+export type TxOsType = 'macos' | 'windows' | 'linux';
+/**
+ * Props interface for the TxStatusBadge component.
+ *
+ * @public
+ */
+export interface StatusBadgeProps {
+    /**
+     * The text content to display in the badge.
+     */
+    text: string;
+    /**
+     * Custom icon class to display.
+     * If not provided, a default icon based on the status tone will be used.
+     * @default ''
+     */
+    icon?: string;
+    /**
+     * The visual status tone of the badge.
+     * Takes precedence over statusKey if both are provided.
+     */
+    status?: StatusTone;
+    /**
+     * A predefined status key that maps to a status tone.
+     * - `granted` → success
+     * - `denied` → danger
+     * - `notDetermined` → warning
+     * - `unsupported` → muted
+     * - other → info
+     * @default ''
+     */
+    statusKey?: StatusKey;
+    /**
+     * The size of the badge.
+     * - `sm`: Small size with compact padding
+     * - `md`: Medium size with standard padding
+     * @default 'md'
+     */
+    size?: 'sm' | 'md';
+    /**
+     * Optional OS/platform marker.
+     * When provided, an OS icon will be rendered before the status icon.
+     */
+    os?: TxOsType;
+    /**
+     * Render OS icon only (hide tone icon).
+     * @default false
+     */
+    osOnly?: boolean;
+}
+/**
+ * Emits interface for the TxStatusBadge component.
+ *
+ * @public
+ */
+export interface StatusBadgeEmits {
+    /**
+     * Emitted when the badge is clicked.
+     * @param event - The mouse event
+     */
+    (e: 'click', event: MouseEvent): void;
+}
+/**
+ * Tone metadata containing color and icon information.
+ *
+ * @internal
+ */
+export interface ToneMeta {
+    /**
+     * CSS color value for the tone.
+     */
+    color: string;
+    /**
+     * Default icon class for the tone.
+     */
+    icon: string;
+}

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

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

package/dist/es/steps/src/TxStep.vue.d.ts

@@ -0,0 +1,47 @@
+import { StepStatus } from './types';
+
+interface Props {
+    title?: string;
+    description?: string;
+    icon?: string;
+    status?: StepStatus;
+    step?: number | string;
+    clickable?: boolean;
+    disabled?: boolean;
+    showLine?: boolean;
+    completedIcon?: string;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    status: string;
+    clickable: boolean;
+    showLine: boolean;
+    completedIcon: string;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    status: string;
+    clickable: boolean;
+    showLine: boolean;
+    completedIcon: string;
+}>>> & Readonly<{}>, {
+    clickable: boolean;
+    status: StepStatus;
+    showLine: boolean;
+    completedIcon: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+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];
+} & {};

package/dist/es/steps/src/TxStep.vue.js

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

package/dist/es/steps/src/TxStep.vue2.js

@@ -0,0 +1,101 @@
+import { defineComponent, inject, computed, createElementBlock, openBlock, normalizeClass, createElementVNode, createCommentVNode, createBlock, unref, toDisplayString } from 'vue';
+import { TxIcon } from '../../icon/index.js';
+
+const _hoisted_1 = { class: "tx-step__head" };
+const _hoisted_2 = {
+  key: 2,
+  class: "tx-step__number"
+};
+const _hoisted_3 = {
+  key: 0,
+  class: "tx-step__line"
+};
+const _hoisted_4 = { class: "tx-step__content" };
+const _hoisted_5 = { class: "tx-step__title" };
+const _hoisted_6 = {
+  key: 0,
+  class: "tx-step__description"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "TxStep",
+  props: {
+    title: {},
+    description: {},
+    icon: {},
+    status: { default: "wait" },
+    step: {},
+    clickable: { type: Boolean, default: true },
+    disabled: { type: Boolean },
+    showLine: { type: Boolean, default: true },
+    completedIcon: { default: "check" }
+  },
+  setup(__props) {
+    const props = __props;
+    const steps = inject("steps");
+    const direction = computed(() => steps?.direction || "horizontal");
+    const size = computed(() => steps?.size || "medium");
+    const isActive = computed(() => {
+      return steps?.activeStep.value === props.step;
+    });
+    const isCompleted = computed(() => {
+      return props.status === "completed" || steps?.activeStep.value !== void 0 && typeof props.step === "number" && typeof steps.activeStep.value === "number" && props.step < steps.activeStep.value;
+    });
+    const status = computed(() => {
+      if (isActive.value)
+        return "active";
+      if (isCompleted.value)
+        return "completed";
+      return props.status;
+    });
+    const stepNumber = computed(() => {
+      if (typeof props.step === "number") {
+        return props.step + 1;
+      }
+      return 1;
+    });
+    const isLast = computed(() => {
+      return false;
+    });
+    function handleClick() {
+      if (props.clickable && !props.disabled && steps) {
+        if (props.step !== void 0)
+          steps.setActiveStep(props.step);
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["tx-step", [
+          `tx-step--${direction.value}`,
+          `tx-step--${size.value}`,
+          {
+            "tx-step--active": isActive.value,
+            "tx-step--completed": isCompleted.value,
+            "tx-step--clickable": __props.clickable && !__props.disabled
+          }
+        ]]),
+        onClick: handleClick
+      }, [
+        createElementVNode("div", _hoisted_1, [
+          createElementVNode("div", {
+            class: normalizeClass(["tx-step__icon", `tx-step__icon--${status.value}`])
+          }, [
+            status.value === "completed" ? (openBlock(), createBlock(unref(TxIcon), {
+              key: 0,
+              name: __props.completedIcon
+            }, null, 8, ["name"])) : __props.icon ? (openBlock(), createBlock(unref(TxIcon), {
+              key: 1,
+              name: __props.icon
+            }, null, 8, ["name"])) : (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(stepNumber.value), 1))
+          ], 2),
+          __props.showLine && !isLast.value ? (openBlock(), createElementBlock("div", _hoisted_3)) : createCommentVNode("", true)
+        ]),
+        createElementVNode("div", _hoisted_4, [
+          createElementVNode("div", _hoisted_5, toDisplayString(__props.title), 1),
+          __props.description ? (openBlock(), createElementBlock("div", _hoisted_6, toDisplayString(__props.description), 1)) : createCommentVNode("", true)
+        ])
+      ], 2);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/steps/src/TxSteps.vue.d.ts

@@ -0,0 +1,47 @@
+import { StepsDirection, StepsSize } from './types';
+
+interface Props {
+    direction?: StepsDirection;
+    size?: StepsSize;
+    active?: number | string;
+}
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    direction: string;
+    size: string;
+    active: number;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    direction: string;
+    size: string;
+    active: number;
+}>>> & Readonly<{}>, {
+    active: number | string;
+    size: StepsSize;
+    direction: StepsDirection;
+}, {}, {}, {}, 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/steps/src/TxSteps.vue.js

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

package/dist/es/steps/src/TxSteps.vue2.js

@@ -0,0 +1,37 @@
+import { defineComponent, ref, watch, provide, createElementBlock, openBlock, normalizeClass, renderSlot } from 'vue';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "TxSteps",
+  props: {
+    direction: { default: "horizontal" },
+    size: { default: "medium" },
+    active: { default: 0 }
+  },
+  setup(__props) {
+    const props = __props;
+    const activeStep = ref(props.active);
+    watch(() => props.active, (newValue) => {
+      activeStep.value = newValue;
+    });
+    provide("steps", {
+      direction: props.direction,
+      size: props.size,
+      activeStep,
+      setActiveStep: (step) => {
+        activeStep.value = step;
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["tx-steps", [
+          `tx-steps--${__props.direction}`,
+          `tx-steps--${__props.size}`
+        ]])
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 2);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/steps/src/index.d.ts

@@ -0,0 +1,3 @@
+export { default as TxStep } from './TxStep.vue';
+export { default as TxSteps } from './TxSteps.vue';
+export type { StepProps, StepsContext, StepsDirection, StepsProps, StepsSize, StepStatus } from './types';

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

@@ -0,0 +1,27 @@
+export type StepsDirection = 'horizontal' | 'vertical';
+export type StepsSize = 'small' | 'medium' | 'large';
+export type StepStatus = 'wait' | 'active' | 'completed' | 'error';
+export interface StepsContext {
+    direction: StepsDirection;
+    size: StepsSize;
+    activeStep: {
+        value: number | string;
+    };
+    setActiveStep: (step: number | string) => void;
+}
+export interface StepsProps {
+    direction?: StepsDirection;
+    size?: StepsSize;
+    active?: number | string;
+}
+export interface StepProps {
+    title?: string;
+    description?: string;
+    icon?: string;
+    status?: StepStatus;
+    step?: number | string;
+    clickable?: boolean;
+    disabled?: boolean;
+    showLine?: boolean;
+    completedIcon?: string;
+}

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

@@ -0,0 +1,4 @@
+import { default as TuffSwitch } from './src/TxSwitch.vue';
+
+export { TuffSwitch };
+export default TuffSwitch;

package/dist/es/switch/index.js

@@ -0,0 +1,7 @@
+import _sfc_main from './src/TxSwitch.vue.js';
+
+_sfc_main.install = (app) => {
+  app.component(_sfc_main.name || "TuffSwitch", _sfc_main);
+};
+
+export { _sfc_main as TuffSwitch, _sfc_main as default };

package/dist/es/switch/src/TxSwitch.vue.d.ts

@@ -0,0 +1,45 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    modelValue?: boolean;
+    disabled?: boolean;
+    size?: "small" | "default" | "large";
+}>, {
+    modelValue: boolean;
+    disabled: boolean;
+    size: string;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: boolean) => void;
+    "update:modelValue": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    modelValue?: boolean;
+    disabled?: boolean;
+    size?: "small" | "default" | "large";
+}>, {
+    modelValue: boolean;
+    disabled: boolean;
+    size: string;
+}>>> & Readonly<{
+    onChange?: ((value: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    size: "small" | "default" | "large";
+    modelValue: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+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];
+} & {};

package/dist/es/switch/src/TxSwitch.vue.js

@@ -0,0 +1,54 @@
+import { defineComponent, computed, createElementBlock, openBlock, withKeys, normalizeClass, withModifiers, createElementVNode } from 'vue';
+
+const _hoisted_1 = ["aria-checked", "aria-disabled", "tabindex", "onKeydown"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "TuffSwitch"
+  },
+  __name: "TxSwitch",
+  props: {
+    modelValue: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false },
+    size: { default: "default" }
+  },
+  emits: ["update:modelValue", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const isActive = computed({
+      get: () => props.modelValue,
+      set: (val) => emit("update:modelValue", val)
+    });
+    function toggle() {
+      if (props.disabled)
+        return;
+      const newVal = !isActive.value;
+      isActive.value = newVal;
+      emit("change", newVal);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        role: "switch",
+        "aria-checked": isActive.value,
+        "aria-disabled": __props.disabled,
+        tabindex: __props.disabled ? -1 : 0,
+        class: normalizeClass(["tuff-switch", [
+          {
+            "is-active": isActive.value,
+            "is-disabled": __props.disabled,
+            [`tuff-switch--${__props.size}`]: __props.size !== "default"
+          }
+        ]]),
+        onClick: toggle,
+        onKeydown: [
+          withKeys(withModifiers(toggle, ["prevent"]), ["enter"]),
+          withKeys(withModifiers(toggle, ["prevent"]), ["space"])
+        ]
+      }, [..._cache[0] || (_cache[0] = [
+        createElementVNode("span", { class: "tuff-switch__thumb" }, null, -1)
+      ])], 42, _hoisted_1);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/switch/src/TxSwitch.vue2.js

@@ -0,0 +1,5 @@
+import _sfc_main from './TxSwitch.vue.js';
+
+
+
+export { _sfc_main as default };