@talex-touch/tuffex 0.3.3

package/dist/lib/utils/toast.js

@@ -0,0 +1,50 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+
+const DEFAULT_DURATION = 2600;
+const toastStore = vue.reactive({
+  items: []
+});
+function generateId() {
+  return `tx-toast-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+function toast(options) {
+  const id = options.id ?? generateId();
+  const duration = options.duration ?? DEFAULT_DURATION;
+  const existingIndex = toastStore.items.findIndex((t) => t.id === id);
+  if (existingIndex !== -1) {
+    toastStore.items.splice(existingIndex, 1);
+  }
+  const item = {
+    id,
+    title: options.title,
+    description: options.description,
+    variant: options.variant ?? "default",
+    duration,
+    createdAt: Date.now()
+  };
+  toastStore.items.push(item);
+  if (duration > 0) {
+    window.setTimeout(() => {
+      dismissToast(id);
+    }, duration);
+  }
+  return id;
+}
+function dismissToast(id) {
+  const index = toastStore.items.findIndex((t) => t.id === id);
+  if (index !== -1) {
+    toastStore.items.splice(index, 1);
+  }
+}
+function clearToasts() {
+  toastStore.items.splice(0, toastStore.items.length);
+}
+
+exports.clearToasts = clearToasts;
+exports.dismissToast = dismissToast;
+exports.toast = toast;
+exports.toastStore = toastStore;

package/dist/lib/utils/vibrate.js

@@ -0,0 +1,149 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const env = require('./env.js');
+
+const VIBRATE_PATTERNS = {
+  light: {
+    pattern: [5],
+    description: "轻微震动 - 适用于轻触反馈"
+  },
+  heavy: {
+    pattern: [5, 30],
+    description: "重度震动 - 适用于重要操作反馈"
+  },
+  medium: {
+    pattern: [10, 15],
+    description: "中等震动 - 适用于一般操作反馈"
+  },
+  bit: {
+    pattern: [2, 1],
+    description: "微震动 - 适用于细微交互反馈"
+  },
+  success: {
+    pattern: [10, 50, 10],
+    description: "成功震动 - 适用于成功操作反馈"
+  },
+  warning: {
+    pattern: [15, 30, 15, 30, 15],
+    description: "警告震动 - 适用于警告提示"
+  },
+  error: {
+    pattern: [20, 100, 20, 100, 20],
+    description: "错误震动 - 适用于错误提示"
+  }
+};
+function useVibrate(type, options = {}) {
+  const { enabled = true, silent = true } = options;
+  if (!enabled)
+    return;
+  const pattern = options.pattern || VIBRATE_PATTERNS[type].pattern;
+  useAutoVibrate(pattern, { silent });
+}
+function useAutoVibrate(duration, options = {}) {
+  const { silent = true } = options;
+  try {
+    if (!env.hasWindow()) {
+      if (!silent) {
+        console.warn("Vibrate API is not available in non-browser environment");
+      }
+      return false;
+    }
+    if (!window.navigator.vibrate) {
+      if (!silent) {
+        console.warn("Vibrate API is not supported in this browser");
+      }
+      return false;
+    }
+    return window.navigator.vibrate(duration);
+  } catch (error) {
+    if (!silent) {
+      console.error("Failed to vibrate:", error);
+    }
+    return false;
+  }
+}
+function stopVibrate() {
+  try {
+    if (env.hasWindow() && window.navigator.vibrate) {
+      window.navigator.vibrate(0);
+      return true;
+    }
+  } catch (error) {
+    console.error("Failed to stop vibration:", error);
+  }
+  return false;
+}
+function isVibrateSupported() {
+  return env.hasWindow() && env.hasNavigator() && typeof navigator.vibrate === "function";
+}
+function createVibratePattern(pattern, description) {
+  return {
+    pattern,
+    description
+  };
+}
+class VibrateManager {
+  constructor(options = {}) {
+    this.enabled = true;
+    this.silent = true;
+    this.enabled = options.enabled ?? true;
+    this.silent = options.silent ?? true;
+  }
+  /**
+   * 设置是否启用震动
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  /**
+   * 设置是否静默模式
+   */
+  setSilent(silent) {
+    this.silent = silent;
+  }
+  /**
+   * 执行震动
+   */
+  vibrate(type, customPattern) {
+    if (!this.enabled)
+      return false;
+    const pattern = customPattern || VIBRATE_PATTERNS[type].pattern;
+    return useAutoVibrate(pattern, { silent: this.silent });
+  }
+  /**
+   * 停止震动
+   */
+  stop() {
+    return stopVibrate();
+  }
+  /**
+   * 检查支持状态
+   */
+  isSupported() {
+    return isVibrateSupported();
+  }
+}
+const defaultVibrateManager = new VibrateManager();
+const vibrate = {
+  light: () => useVibrate("light"),
+  heavy: () => useVibrate("heavy"),
+  medium: () => useVibrate("medium"),
+  bit: () => useVibrate("bit"),
+  success: () => useVibrate("success"),
+  warning: () => useVibrate("warning"),
+  error: () => useVibrate("error"),
+  stop: stopVibrate,
+  isSupported: isVibrateSupported
+};
+
+exports.VIBRATE_PATTERNS = VIBRATE_PATTERNS;
+exports.VibrateManager = VibrateManager;
+exports.createVibratePattern = createVibratePattern;
+exports.defaultVibrateManager = defaultVibrateManager;
+exports.isVibrateSupported = isVibrateSupported;
+exports.stopVibrate = stopVibrate;
+exports.useAutoVibrate = useAutoVibrate;
+exports.useVibrate = useVibrate;
+exports.vibrate = vibrate;

package/dist/lib/utils/withInstall.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function withInstall(component) {
+  component.install = (app) => {
+    const name = component.name;
+    app.component(name, component);
+  };
+  return component;
+}
+
+exports.withInstall = withInstall;

package/dist/lib/virtual-list/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const withInstall = require('../utils/withInstall.js');
+const TxVirtualList = require('./src/TxVirtualList.vue.js');
+
+const VirtualList = withInstall.withInstall(TxVirtualList.default);
+
+exports.TxVirtualList = TxVirtualList.default;
+exports.VirtualList = VirtualList;
+exports.default = VirtualList;

package/dist/lib/virtual-list/src/TxVirtualList.vue.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxVirtualList_vue_vue_type_script_setup_true_lang = require('./TxVirtualList.vue2.js');
+;/* empty css                    */
+const _pluginVue_exportHelper = require('../../_virtual/_plugin-vue_export-helper.js');
+
+const TxVirtualList = /* @__PURE__ */ _pluginVue_exportHelper.default(TxVirtualList_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-3dc3437a"]]);
+
+exports.default = TxVirtualList;

package/dist/lib/virtual-list/src/TxVirtualList.vue2.js

@@ -0,0 +1,151 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxVirtualList" },
+  __name: "TxVirtualList",
+  props: {
+    items: { default: () => [] },
+    itemHeight: {},
+    height: { default: 320 },
+    overscan: { default: 4 },
+    itemKey: {}
+  },
+  emits: ["scroll"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const containerRef = vue.ref(null);
+    const scrollTop = vue.ref(0);
+    const viewHeight = vue.ref(0);
+    let resizeObserver = null;
+    const resolvedHeight = vue.computed(() => typeof props.height === "number" ? `${props.height}px` : props.height);
+    function parseHeight(value) {
+      if (typeof value === "number")
+        return value;
+      const trimmed = value.trim();
+      if (trimmed.endsWith("%") || trimmed.endsWith("vh") || trimmed.endsWith("vw") || trimmed.endsWith("rem") || trimmed.endsWith("em"))
+        return null;
+      if (trimmed.endsWith("px")) {
+        const parsed = Number.parseFloat(trimmed.slice(0, -2));
+        return Number.isFinite(parsed) ? parsed : null;
+      }
+      if (/^\d+(\.\d+)?$/.test(trimmed)) {
+        const numeric = Number.parseFloat(trimmed);
+        return Number.isFinite(numeric) ? numeric : null;
+      }
+      return null;
+    }
+    function updateViewport() {
+      if (!containerRef.value)
+        return;
+      const height = containerRef.value.clientHeight;
+      if (height > 0)
+        viewHeight.value = height;
+    }
+    vue.watch(
+      () => props.height,
+      (v) => {
+        const parsed = parseHeight(v);
+        if (parsed != null) {
+          viewHeight.value = parsed;
+          return;
+        }
+        updateViewport();
+      },
+      { immediate: true }
+    );
+    vue.onMounted(() => {
+      updateViewport();
+      if (typeof ResizeObserver !== "undefined" && containerRef.value) {
+        resizeObserver = new ResizeObserver(() => updateViewport());
+        resizeObserver.observe(containerRef.value);
+      }
+    });
+    vue.onBeforeUnmount(() => {
+      resizeObserver?.disconnect();
+      resizeObserver = null;
+    });
+    const startIndex = vue.computed(() => {
+      const base = Math.floor(scrollTop.value / props.itemHeight);
+      return Math.max(0, base - (props.overscan ?? 0));
+    });
+    const endIndex = vue.computed(() => {
+      const base = Math.ceil((scrollTop.value + viewHeight.value) / props.itemHeight);
+      return Math.min(props.items.length, base + (props.overscan ?? 0));
+    });
+    const visibleItems = vue.computed(() => {
+      return props.items.slice(startIndex.value, endIndex.value).map((item, i) => ({
+        item,
+        index: startIndex.value + i
+      }));
+    });
+    const totalHeight = vue.computed(() => props.items.length * props.itemHeight);
+    const offsetTop = vue.computed(() => startIndex.value * props.itemHeight);
+    function onScroll(e) {
+      const el = e.target;
+      scrollTop.value = el.scrollTop;
+      emit("scroll", { scrollTop: scrollTop.value, startIndex: startIndex.value, endIndex: endIndex.value });
+    }
+    function resolveKey(item, index) {
+      if (typeof props.itemKey === "function")
+        return props.itemKey(item, index);
+      if (typeof props.itemKey === "string" && props.itemKey)
+        return item?.[props.itemKey] ?? index;
+      return index;
+    }
+    function scrollToIndex(index) {
+      if (!containerRef.value)
+        return;
+      containerRef.value.scrollTop = Math.max(0, index) * props.itemHeight;
+    }
+    function scrollToTop() {
+      if (containerRef.value)
+        containerRef.value.scrollTop = 0;
+    }
+    function scrollToBottom() {
+      if (containerRef.value)
+        containerRef.value.scrollTop = Math.max(0, totalHeight.value - viewHeight.value);
+    }
+    __expose({ scrollToIndex, scrollToTop, scrollToBottom });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        ref_key: "containerRef",
+        ref: containerRef,
+        class: "tx-virtual-list",
+        style: vue.normalizeStyle({ height: resolvedHeight.value }),
+        onScroll
+      }, [
+        vue.createElementVNode("div", {
+          class: "tx-virtual-list__spacer",
+          style: vue.normalizeStyle({ height: `${totalHeight.value}px` })
+        }, [
+          vue.createElementVNode("div", {
+            class: "tx-virtual-list__items",
+            style: vue.normalizeStyle({ transform: `translateY(${offsetTop.value}px)` })
+          }, [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(visibleItems.value, (entry) => {
+              return vue.openBlock(), vue.createElementBlock("div", {
+                key: resolveKey(entry.item, entry.index),
+                class: "tx-virtual-list__item",
+                style: vue.normalizeStyle({ height: `${__props.itemHeight}px` })
+              }, [
+                vue.renderSlot(_ctx.$slots, "item", {
+                  item: entry.item,
+                  index: entry.index
+                }, () => [
+                  vue.createTextVNode(vue.toDisplayString(entry.item), 1)
+                ], true)
+              ], 4);
+            }), 128))
+          ], 4)
+        ], 4)
+      ], 36);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/style.css

@@ -0,0 +1 @@
+@import "./es/components.css";

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@talex-touch/tuffex",
+  "version": "0.3.3",
+  "author": "TalexDreamSoul<TalexDreamSoul@gmail.com>",
+  "description": "TuffEx - Modern Vue3 component library with beautiful animations and tactile experience.",
+  "keywords": [
+    "tuff",
+    "tuffex",
+    "talex-touch",
+    "vue3",
+    "components",
+    "ui-library",
+    "animation",
+    "tactile",
+    "glassmorphism"
+  ],
+  "type": "module",
+  "main": "dist/lib/index.js",
+  "module": "dist/es/index.js",
+  "types": "dist/es/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/es/index.d.ts",
+      "import": "./dist/es/index.js",
+      "require": "./dist/lib/index.js"
+    },
+    "./style.css": "./dist/es/components.css",
+    "./utils": {
+      "types": "./dist/es/utils/index.d.ts",
+      "import": "./dist/es/utils/index.js",
+      "require": "./dist/lib/utils/index.js"
+    },
+    "./*": "./*"
+  },
+  "scripts": {
+    "build": "node --loader ts-node/esm ./node_modules/gulp/bin/gulp.js -f packages/script/build/index.ts",
+    "build:vite": "vite build",
+    "component:create": "esno ./utils/create/index.ts",
+    "comp:create": "esno ./utils/createComponent/index.ts",
+    "dev": "vitepress dev docs --port 8000--host",
+    "lint": "pnpm exec eslint --cache .",
+    "lint:fix": "pnpm exec eslint --cache --fix .",
+    "docs:dev": "vitepress dev docs --port 8000 --host",
+    "docs:new": "esno ./utils/createVitepressComp/index.ts",
+    "docs:build": "vitepress build docs"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "vue": "^3.4.0"
+  },
+  "dependencies": {
+    "@better-scroll/core": "^2.5.1",
+    "@better-scroll/pull-down": "^2.5.1",
+    "@better-scroll/pull-up": "^2.5.1",
+    "@better-scroll/scroll-bar": "^2.5.1",
+    "@floating-ui/vue": "^1.1.9",
+    "@number-flow/vue": "^0.4.8",
+    "@vueuse/core": "^13.0.0",
+    "dompurify": "^3.2.4",
+    "gsap": "^3.13.0",
+    "marked": "^12.0.2",
+    "v-wave": "^3.0.4"
+  },
+  "devDependencies": {
+    "@iconify-json/carbon": "^1.2.8",
+    "@iconify-json/ri": "^1.2.6",
+    "@iconify-json/simple-icons": "^1.2.23",
+    "@types/gulp": "^4.0.17",
+    "@types/gulp-autoprefixer": "^0.0.37",
+    "@types/gulp-sass": "^5.0.4",
+    "@types/node": "^22.10.0",
+    "@vitejs/plugin-vue": "^5.2.0",
+    "chalk": "^5.3.0",
+    "dotenv": "^16.4.0",
+    "esno": "^4.8.0",
+    "gulp": "^5.0.0",
+    "gulp-autoprefixer": "^9.0.0",
+    "gulp-sass": "^5.1.0",
+    "sass": "^1.89.0",
+    "search-insights": "^2.17.3",
+    "sucrase": "^3.35.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.0",
+    "unocss": "^66.3.3",
+    "vite": "^6.0.0",
+    "vite-plugin-dts": "^4.3.0",
+    "vitepress": "^1.5.0",
+    "vue": "^3.5.0"
+  }
+}