@talex-touch/tuffex 0.3.3 → 0.3.4

package/dist/lib/card/src/TxCard.vue2.js

@@ -3,6 +3,8 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 
 const vue = require('vue');
+const TxBaseSurface_vue_vue_type_script_setup_true_lang = require('../../base-surface/src/TxBaseSurface.vue.js');
+;/* empty css                                       */
 const TxSpinner_vue_vue_type_script_setup_true_lang = require('../../spinner/src/TxSpinner.vue.js');
 ;/* empty css                                */
 
@@ -29,7 +31,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
   __name: "TxCard",
   props: {
     variant: { default: "solid" },
-    background: { default: "blur" },
+    background: { default: "pure" },
     shadow: { default: "none" },
     size: { default: "medium" },
     radius: { default: void 0 },
@@ -37,7 +39,19 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     glassBlur: { type: Boolean, default: true },
     glassBlurAmount: { default: 22 },
     glassOverlay: { type: Boolean, default: true },
-    glassOverlayOpacity: { default: 0.22 },
+    glassOverlayOpacity: { default: 0.18 },
+    maskOpacity: { default: 0.75 },
+    fallbackMaskOpacity: { default: 0.26 },
+    surfaceMoving: { type: Boolean, default: false },
+    refractionStrength: { default: 62 },
+    refractionProfile: { default: "filmic" },
+    refractionTone: { default: "vivid" },
+    refractionAngle: { default: -24 },
+    refractionLightFollowMouse: { type: Boolean, default: false },
+    refractionLightFollowIntensity: { default: 0.45 },
+    refractionLightSpring: { type: Boolean, default: true },
+    refractionLightSpringStiffness: { default: 0.18 },
+    refractionLightSpringDamping: { default: 0.84 },
     clickable: { type: Boolean, default: false },
     loading: { type: Boolean, default: false },
     loadingSpinnerSize: { default: void 0 },
@@ -50,22 +64,37 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
   setup(__props, { emit: __emit }) {
     const props = __props;
     const emit = __emit;
-    const {
-      variant,
-      background,
-      shadow,
-      size,
-      clickable,
-      loading,
-      disabled,
-      inertial,
-      inertialMaxOffset,
-      inertialRebound,
-      glassBlur,
-      glassBlurAmount,
-      glassOverlay,
-      glassOverlayOpacity
-    } = vue.toRefs(props);
+    const variant = vue.toRef(props, "variant");
+    const background = vue.toRef(props, "background");
+    const shadow = vue.toRef(props, "shadow");
+    const size = vue.toRef(props, "size");
+    const clickable = vue.toRef(props, "clickable");
+    const loading = vue.toRef(props, "loading");
+    const disabled = vue.toRef(props, "disabled");
+    const inertial = vue.toRef(props, "inertial");
+    const glassBlur = vue.toRef(props, "glassBlur");
+    const glassBlurAmount = vue.toRef(props, "glassBlurAmount");
+    const glassOverlay = vue.toRef(props, "glassOverlay");
+    const glassOverlayOpacity = vue.toRef(props, "glassOverlayOpacity");
+    const maskOpacity = vue.toRef(props, "maskOpacity");
+    const fallbackMaskOpacity = vue.toRef(props, "fallbackMaskOpacity");
+    const externalSurfaceMoving = vue.toRef(props, "surfaceMoving");
+    const refractionStrength = vue.toRef(props, "refractionStrength");
+    const refractionProfile = vue.toRef(props, "refractionProfile");
+    const refractionTone = vue.toRef(props, "refractionTone");
+    const refractionAngle = vue.toRef(props, "refractionAngle");
+    const refractionLightFollowMouse = vue.toRef(props, "refractionLightFollowMouse");
+    const refractionLightFollowIntensity = vue.toRef(props, "refractionLightFollowIntensity");
+    const refractionLightSpring = vue.toRef(props, "refractionLightSpring");
+    const refractionLightSpringStiffness = vue.toRef(props, "refractionLightSpringStiffness");
+    const refractionLightSpringDamping = vue.toRef(props, "refractionLightSpringDamping");
+    const motionX = vue.ref(0);
+    const motionY = vue.ref(0);
+    const surfaceMoving = vue.ref(false);
+    const lightPointX = vue.ref(0.5);
+    const lightPointY = vue.ref(0.5);
+    const lightRatioX = vue.ref(0);
+    const lightRatioY = vue.ref(0);
     const resolvedRadius = vue.computed(() => {
       if (typeof props.radius === "number")
         return props.radius;
@@ -85,12 +114,89 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
         return props.loadingSpinnerSize;
       return 12;
     });
-    const motionX = vue.ref(0);
-    const motionY = vue.ref(0);
+    const surfaceMode = vue.computed(() => {
+      return background.value;
+    });
+    const surfaceRefractionProfile = vue.computed(() => {
+      if (background.value !== "refraction")
+        return void 0;
+      return refractionProfile.value;
+    });
+    const surfaceRefractionTone = vue.computed(() => {
+      if (background.value !== "refraction")
+        return void 0;
+      return refractionTone.value;
+    });
+    const surfaceBlur = vue.computed(() => {
+      if (background.value === "blur")
+        return 30;
+      if (background.value === "glass" || background.value === "refraction")
+        return glassBlur.value ? glassBlurAmount.value : 0;
+      return 0;
+    });
+    const surfaceOverlayOpacity = vue.computed(() => {
+      if (background.value !== "glass" && background.value !== "refraction")
+        return 0;
+      return glassOverlay.value ? glassOverlayOpacity.value : 0;
+    });
+    const surfaceRefractionStrength = vue.computed(() => {
+      if (background.value !== "refraction")
+        return void 0;
+      const baseStrength = clamp(refractionStrength.value, 0, 100);
+      if (!refractionLightFollowMouse.value) {
+        return baseStrength;
+      }
+      const intensity = clamp(refractionLightFollowIntensity.value, 0, 1);
+      const distance = clamp(Math.hypot(lightRatioX.value, lightRatioY.value), 0, 1);
+      return clamp(baseStrength + distance * 16 * intensity, 0, 100);
+    });
+    const surfaceRefractionAngle = vue.computed(() => {
+      if (background.value !== "refraction")
+        return void 0;
+      const baseAngle = normalizeAngleDeg(refractionAngle.value);
+      if (!refractionLightFollowMouse.value) {
+        return baseAngle;
+      }
+      if (Math.abs(lightRatioX.value) < 0.01 && Math.abs(lightRatioY.value) < 0.01) {
+        return baseAngle;
+      }
+      const intensity = clamp(refractionLightFollowIntensity.value, 0, 1);
+      const pointerAngle = Math.atan2(lightRatioY.value, lightRatioX.value) * (180 / Math.PI);
+      return lerpAngleDeg(baseAngle, pointerAngle, intensity);
+    });
+    const surfaceRefractionLightX = vue.computed(() => {
+      if (background.value !== "refraction" || !refractionLightFollowMouse.value) {
+        return void 0;
+      }
+      return lightPointX.value;
+    });
+    const surfaceRefractionLightY = vue.computed(() => {
+      if (background.value !== "refraction" || !refractionLightFollowMouse.value) {
+        return void 0;
+      }
+      return lightPointY.value;
+    });
+    const surfaceColor = vue.computed(() => {
+      if (background.value !== "mask")
+        return void 0;
+      return "var(--tx-card-fake-background, var(--tx-bg-color-overlay, #fff))";
+    });
+    const surfaceOpacity = vue.computed(() => {
+      if (background.value === "mask")
+        return clamp(maskOpacity.value, 0, 1);
+      return void 0;
+    });
+    const mergedSurfaceMoving = vue.computed(() => {
+      return surfaceMoving.value || !!externalSurfaceMoving.value;
+    });
     let targetX = 0;
     let targetY = 0;
+    let lightTargetX = 0.5;
+    let lightTargetY = 0.5;
     let velocityX = 0;
     let velocityY = 0;
+    let lightVelocityX = 0;
+    let lightVelocityY = 0;
     let lastTs = 0;
     let rafId = null;
     let isReturning = false;
@@ -100,6 +206,13 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     function lerp(a, b, t) {
       return a + (b - a) * t;
     }
+    function normalizeAngleDeg(angle) {
+      return ((angle + 180) % 360 + 360) % 360 - 180;
+    }
+    function lerpAngleDeg(from, to, t) {
+      const delta = normalizeAngleDeg(to - from);
+      return normalizeAngleDeg(from + delta * t);
+    }
     function stopRaf() {
       if (rafId == null)
         return;
@@ -110,27 +223,60 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
       const dtRaw = lastTs ? (ts - lastTs) / 16.6667 : 1;
       lastTs = ts;
       const dt = clamp(dtRaw, 0.5, 2);
-      const rebound = clamp(props.inertialRebound, 0, 1);
-      const followStiffness = 0.085;
-      const followDamping = 0.9;
-      const returnStiffness = lerp(0.06, 0.12, rebound);
-      const returnDamping = lerp(0.96, 0.84, rebound);
-      const stiffness = isReturning ? returnStiffness : followStiffness;
-      const damping = isReturning ? returnDamping : followDamping;
-      velocityX += (targetX - motionX.value) * stiffness * dt;
-      velocityY += (targetY - motionY.value) * stiffness * dt;
-      const damp = damping ** dt;
-      velocityX *= damp;
-      velocityY *= damp;
-      motionX.value += velocityX;
-      motionY.value += velocityY;
-      const closeX = Math.abs(targetX - motionX.value) < 0.08 && Math.abs(velocityX) < 0.08;
-      const closeY = Math.abs(targetY - motionY.value) < 0.08 && Math.abs(velocityY) < 0.08;
-      if (closeX && closeY) {
-        motionX.value = targetX;
-        motionY.value = targetY;
-        velocityX = 0;
-        velocityY = 0;
+      let motionSettled = true;
+      let lightSettled = true;
+      if (props.inertial) {
+        const rebound = clamp(props.inertialRebound, 0, 1);
+        const followStiffness = 0.085;
+        const followDamping = 0.9;
+        const returnStiffness = lerp(0.06, 0.12, rebound);
+        const returnDamping = lerp(0.96, 0.84, rebound);
+        const stiffness = isReturning ? returnStiffness : followStiffness;
+        const damping = isReturning ? returnDamping : followDamping;
+        velocityX += (targetX - motionX.value) * stiffness * dt;
+        velocityY += (targetY - motionY.value) * stiffness * dt;
+        const damp = damping ** dt;
+        velocityX *= damp;
+        velocityY *= damp;
+        motionX.value += velocityX;
+        motionY.value += velocityY;
+        const closeX = Math.abs(targetX - motionX.value) < 0.08 && Math.abs(velocityX) < 0.08;
+        const closeY = Math.abs(targetY - motionY.value) < 0.08 && Math.abs(velocityY) < 0.08;
+        motionSettled = closeX && closeY;
+        if (motionSettled) {
+          motionX.value = targetX;
+          motionY.value = targetY;
+          velocityX = 0;
+          velocityY = 0;
+        }
+      }
+      if (refractionLightFollowMouse.value && background.value === "refraction") {
+        if (refractionLightSpring.value) {
+          const springStiffness = clamp(refractionLightSpringStiffness.value, 0.01, 0.55);
+          const springDamping = clamp(refractionLightSpringDamping.value, 0.55, 0.99);
+          lightVelocityX += (lightTargetX - lightPointX.value) * springStiffness * dt;
+          lightVelocityY += (lightTargetY - lightPointY.value) * springStiffness * dt;
+          const lightDamp = springDamping ** dt;
+          lightVelocityX *= lightDamp;
+          lightVelocityY *= lightDamp;
+          lightPointX.value = clamp(lightPointX.value + lightVelocityX, 0, 1);
+          lightPointY.value = clamp(lightPointY.value + lightVelocityY, 0, 1);
+        } else {
+          lightPointX.value = lightTargetX;
+          lightPointY.value = lightTargetY;
+          lightVelocityX = 0;
+          lightVelocityY = 0;
+        }
+        lightRatioX.value = clamp(lightPointX.value * 2 - 1, -1, 1);
+        lightRatioY.value = clamp(lightPointY.value * 2 - 1, -1, 1);
+        const closeLightX = Math.abs(lightTargetX - lightPointX.value) < 2e-3 && Math.abs(lightVelocityX) < 2e-3;
+        const closeLightY = Math.abs(lightTargetY - lightPointY.value) < 2e-3 && Math.abs(lightVelocityY) < 2e-3;
+        lightSettled = closeLightX && closeLightY;
+      }
+      if (motionSettled && lightSettled) {
+        if (props.inertial) {
+          surfaceMoving.value = false;
+        }
         lastTs = 0;
         rafId = null;
         return;
@@ -142,11 +288,37 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
         return;
       rafId = requestAnimationFrame(tickFrame);
     }
-    function onMouseMove(ev) {
-      if (!props.inertial)
+    function updateRefractionLight(ev) {
+      if (!refractionLightFollowMouse.value)
+        return;
+      if (background.value !== "refraction")
         return;
+      const el = ev.currentTarget;
+      if (!el)
+        return;
+      const rect = el.getBoundingClientRect();
+      if (!rect.width || !rect.height)
+        return;
+      const localX = clamp(ev.clientX - rect.left, 0, rect.width);
+      const localY = clamp(ev.clientY - rect.top, 0, rect.height);
+      lightTargetX = localX / rect.width;
+      lightTargetY = localY / rect.height;
+      if (!refractionLightSpring.value) {
+        lightPointX.value = lightTargetX;
+        lightPointY.value = lightTargetY;
+        lightRatioX.value = clamp(lightPointX.value * 2 - 1, -1, 1);
+        lightRatioY.value = clamp(lightPointY.value * 2 - 1, -1, 1);
+        lightVelocityX = 0;
+        lightVelocityY = 0;
+      }
+      ensureRaf();
+    }
+    function onMouseMove(ev) {
       if (props.disabled)
         return;
+      updateRefractionLight(ev);
+      if (!props.inertial)
+        return;
       const el = ev.currentTarget;
       if (!el)
         return;
@@ -163,14 +335,29 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
       const easedX = Math.sign(ratioX) * Math.abs(ratioX) ** 0.85;
       const easedY = Math.sign(ratioY) * Math.abs(ratioY) ** 0.85;
       const max = props.inertialMaxOffset;
+      surfaceMoving.value = true;
       targetX = easedX * max;
       targetY = easedY * max;
       ensureRaf();
     }
     function onMouseLeave() {
+      if (refractionLightFollowMouse.value && background.value === "refraction") {
+        lightTargetX = 0.5;
+        lightTargetY = 0.5;
+        if (!refractionLightSpring.value) {
+          lightPointX.value = 0.5;
+          lightPointY.value = 0.5;
+          lightRatioX.value = 0;
+          lightRatioY.value = 0;
+          lightVelocityX = 0;
+          lightVelocityY = 0;
+        }
+        ensureRaf();
+      }
       if (!props.inertial)
         return;
       const rebound = clamp(props.inertialRebound, 0, 1);
+      surfaceMoving.value = true;
       isReturning = true;
       velocityX *= rebound;
       velocityY *= rebound;
@@ -178,6 +365,32 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
       targetY = 0;
       ensureRaf();
     }
+    function resetRefractionLightState() {
+      lightTargetX = 0.5;
+      lightTargetY = 0.5;
+      lightPointX.value = 0.5;
+      lightPointY.value = 0.5;
+      lightRatioX.value = 0;
+      lightRatioY.value = 0;
+      lightVelocityX = 0;
+      lightVelocityY = 0;
+    }
+    vue.watch([background, refractionLightFollowMouse], ([bg, follow]) => {
+      if (bg !== "refraction" || !follow) {
+        resetRefractionLightState();
+      }
+    });
+    vue.watch(inertial, (enabled) => {
+      if (!enabled) {
+        surfaceMoving.value = false;
+        motionX.value = 0;
+        motionY.value = 0;
+        targetX = 0;
+        targetY = 0;
+        velocityX = 0;
+        velocityY = 0;
+      }
+    });
     vue.onBeforeUnmount(() => {
       stopRaf();
     });
@@ -191,15 +404,15 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     return (_ctx, _cache) => {
       return vue.openBlock(), vue.createElementBlock("div", {
         class: vue.normalizeClass(["tx-card", [
-          `is-${vue.unref(variant)}`,
-          `is-bg-${vue.unref(background)}`,
-          `is-shadow-${vue.unref(shadow)}`,
-          `is-${vue.unref(size)}`,
+          `is-${variant.value}`,
+          `is-bg-${background.value}`,
+          `is-shadow-${shadow.value}`,
+          `is-${size.value}`,
           {
-            "is-clickable": vue.unref(clickable),
-            "is-loading": vue.unref(loading),
-            "is-disabled": vue.unref(disabled),
-            "is-inertial": vue.unref(inertial)
+            "is-clickable": clickable.value,
+            "is-loading": loading.value,
+            "is-disabled": disabled.value,
+            "is-inertial": inertial.value
           }
         ]]),
         style: vue.normalizeStyle({
@@ -207,13 +420,31 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
           "--tx-card-padding": `${resolvedPadding.value}px`,
           "--tx-card-dx": `${motionX.value}px`,
           "--tx-card-dy": `${motionY.value}px`,
-          "--tx-card-glass-blur": `${vue.unref(glassBlur) ? vue.unref(glassBlurAmount) : 0}px`,
-          "--tx-card-glass-overlay-opacity": `${vue.unref(glassOverlay) ? vue.unref(glassOverlayOpacity) : 0}`
+          "--tx-surface-refraction-mask-color": "var(--tx-card-fake-background, var(--tx-bg-color-overlay, #fff))"
         }),
         onClick,
         onMousemove: onMouseMove,
         onMouseleave: onMouseLeave
       }, [
+        vue.createVNode(TxBaseSurface_vue_vue_type_script_setup_true_lang.default, {
+          class: "tx-card__surface",
+          mode: surfaceMode.value,
+          preset: "card",
+          moving: mergedSurfaceMoving.value,
+          "fallback-mask-opacity": fallbackMaskOpacity.value,
+          radius: resolvedRadius.value,
+          color: surfaceColor.value,
+          opacity: surfaceOpacity.value,
+          blur: surfaceBlur.value,
+          "overlay-opacity": surfaceOverlayOpacity.value,
+          "refraction-strength": surfaceRefractionStrength.value,
+          "refraction-profile": surfaceRefractionProfile.value,
+          "refraction-tone": surfaceRefractionTone.value,
+          "refraction-angle": surfaceRefractionAngle.value,
+          "refraction-light-x": surfaceRefractionLightX.value,
+          "refraction-light-y": surfaceRefractionLightY.value,
+          "aria-hidden": "true"
+        }, null, 8, ["mode", "moving", "fallback-mask-opacity", "radius", "color", "opacity", "blur", "overlay-opacity", "refraction-strength", "refraction-profile", "refraction-tone", "refraction-angle", "refraction-light-x", "refraction-light-y"]),
         _ctx.$slots.cover ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
           vue.renderSlot(_ctx.$slots, "cover", {}, void 0, true)
         ])) : vue.createCommentVNode("", true),
@@ -226,7 +457,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
         _ctx.$slots.footer ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_4, [
           vue.renderSlot(_ctx.$slots, "footer", {}, void 0, true)
         ])) : vue.createCommentVNode("", true),
-        vue.unref(loading) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_5, [
+        loading.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_5, [
           vue.createVNode(TxSpinner_vue_vue_type_script_setup_true_lang.default, { size: resolvedSpinnerSize.value }, null, 8, ["size"])
         ])) : vue.createCommentVNode("", true)
       ], 38);

package/dist/lib/card-item/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 
-const withInstall = require('../utils/withInstall.js');
+const withInstall = require('../packages/tuffex/packages/utils/withInstall.js');
 const TxCardItem = require('./src/TxCardItem.vue.js');
 
 const CardItem = withInstall.withInstall(TxCardItem.default);

package/dist/lib/cascader/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 
-const withInstall = require('../utils/withInstall.js');
+const withInstall = require('../packages/tuffex/packages/utils/withInstall.js');
 const TxCascader = require('./src/TxCascader.vue.js');
 
 const Cascader = withInstall.withInstall(TxCascader.default);

package/dist/lib/cascader/src/TxCascader.vue.js

@@ -6,6 +6,6 @@ const TxCascader_vue_vue_type_script_setup_true_lang = require('./TxCascader.vue
 ;/* empty css                 */
 const _pluginVue_exportHelper = require('../../_virtual/_plugin-vue_export-helper.js');
 
-const TxCascader = /* @__PURE__ */ _pluginVue_exportHelper.default(TxCascader_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-c3af99ed"]]);
+const TxCascader = /* @__PURE__ */ _pluginVue_exportHelper.default(TxCascader_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-904ab1b6"]]);
 
 exports.default = TxCascader;

package/dist/lib/cascader/src/TxCascader.vue2.js

@@ -305,10 +305,8 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
           emit("open");
         else
           emit("close");
-        if (!v) {
-          query.value = "";
+        if (!v)
           return;
-        }
         await vue.nextTick();
         if (props.load && activePath.value.length) {
           const node = findNodeByPath(activePath.value);

package/dist/lib/chat/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 
-const withInstall = require('../utils/withInstall.js');
+const withInstall = require('../packages/tuffex/packages/utils/withInstall.js');
 const TxChatComposer = require('./src/TxChatComposer.vue.js');
 const TxChatList = require('./src/TxChatList.vue.js');
 const TxChatMessage = require('./src/TxChatMessage.vue.js');

package/dist/lib/chat/src/TxChatComposer.vue.js

@@ -6,6 +6,6 @@ const TxChatComposer_vue_vue_type_script_setup_true_lang = require('./TxChatComp
 ;/* empty css                     */
 const _pluginVue_exportHelper = require('../../_virtual/_plugin-vue_export-helper.js');
 
-const TxChatComposer = /* @__PURE__ */ _pluginVue_exportHelper.default(TxChatComposer_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-1871fd77"]]);
+const TxChatComposer = /* @__PURE__ */ _pluginVue_exportHelper.default(TxChatComposer_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-7ed48b7a"]]);
 
 exports.default = TxChatComposer;

package/dist/lib/chat/src/TxChatComposer.vue2.js

@@ -32,6 +32,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
       set: (v) => emit("update:modelValue", v)
     });
     const textareaRef = vue.ref(null);
+    void textareaRef.value;
     function trySend() {
       if (props.disabled || props.submitting)
         return;

package/dist/lib/code-editor/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const withInstall = require('../packages/tuffex/packages/utils/withInstall.js');
+const TxCodeEditor = require('./src/TxCodeEditor.vue.js');
+const TxCodeEditorToolbar = require('./src/TxCodeEditorToolbar.vue.js');
+
+const CodeEditor = withInstall.withInstall(TxCodeEditor.default);
+const CodeEditorToolbar = withInstall.withInstall(TxCodeEditorToolbar.default);
+
+exports.TxCodeEditor = TxCodeEditor.default;
+exports.TxCodeEditorToolbar = TxCodeEditorToolbar.default;
+exports.CodeEditor = CodeEditor;
+exports.CodeEditorToolbar = CodeEditorToolbar;
+exports.default = CodeEditor;

package/dist/lib/code-editor/src/TxCodeEditor.vue.js

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