@gradient-ui/core 0.6.0 → 1.0.0

package/dist/GExpandTransition.vue_vue_type_script_setup_true_lang-ztMeJVQO.js

@@ -0,0 +1,170 @@
+import { defineComponent, useAttrs, computed, openBlock, createBlock, Transition, mergeProps, unref, withCtx, renderSlot } from "vue";
+import { u as useReducedMotion, r as resolveTransitionOptions, m as makeGTransitionProps } from "./transition-DVGMCo2o.js";
+import { d as isClientHTMLElement } from "./environment-o0e-UUbv.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  inheritAttrs: !1,
+  __name: "GExpandTransition",
+  props: makeGTransitionProps({
+    name: "expand"
+  }),
+  emits: ["before-enter", "after-enter", "before-leave", "leave", "after-leave", "enter-cancelled", "leave-cancelled"],
+  setup(__props, { emit: __emit }) {
+    const props = __props, emit = __emit, attrs = useAttrs(), reducedMotion = useReducedMotion(), defaultTransition = computed(() => ({
+      name: props.name,
+      appear: props.appear,
+      mode: props.mode,
+      duration: props.duration,
+      enterDuration: props.enterDuration,
+      leaveDuration: props.leaveDuration,
+      easing: props.easing,
+      enterEasing: props.enterEasing,
+      leaveEasing: props.leaveEasing
+    })), resolvedTransition = computed(
+      () => resolveTransitionOptions(props.transition, defaultTransition.value)
+    ), isDisabled = computed(
+      () => props.disabled || reducedMotion.value || resolvedTransition.value.disabled
+    ), transitionMode = computed(
+      () => resolvedTransition.value.mode === "default" ? void 0 : resolvedTransition.value.mode
+    );
+    function readCssDuration(el, token, fallback) {
+      const raw = getComputedStyle(el).getPropertyValue(token).trim();
+      return parseDuration(raw, fallback, el);
+    }
+    function parseDuration(value, fallback, el) {
+      if (value === void 0 || value === "") return fallback;
+      if (typeof value == "number") return value;
+      const resolvedValue = resolveCssVar(value, el).trim();
+      if (resolvedValue.endsWith("ms"))
+        return Number.parseFloat(resolvedValue);
+      if (resolvedValue.endsWith("s"))
+        return Number.parseFloat(resolvedValue) * 1e3;
+      const parsed = Number.parseFloat(resolvedValue);
+      return Number.isNaN(parsed) ? fallback : parsed;
+    }
+    function resolveCssVar(value, el) {
+      const match = value.match(/var\((--[^,)]+)/);
+      return match && getComputedStyle(el).getPropertyValue(match[1]).trim() || value;
+    }
+    function getDuration(el, phase) {
+      const transition = resolvedTransition.value, fallback = readCssDuration(
+        el,
+        phase === "enter" ? "--g-token-duration-enter" : "--g-token-duration-leave",
+        phase === "enter" ? 220 : 180
+      );
+      return parseDuration(
+        phase === "enter" ? transition.enterDuration ?? transition.duration : transition.leaveDuration ?? transition.duration,
+        fallback,
+        el
+      );
+    }
+    function getEasing(phase) {
+      const transition = resolvedTransition.value;
+      return (phase === "enter" ? transition.enterEasing : transition.leaveEasing) ?? transition.easing ?? "var(--g-token-easing-standard)";
+    }
+    function saveInitialStyles(el) {
+      el._gExpandInitialStyles = {
+        height: el.style.height,
+        overflow: el.style.overflow,
+        transitionDuration: el.style.transitionDuration,
+        transitionProperty: el.style.transitionProperty,
+        transitionTimingFunction: el.style.transitionTimingFunction
+      };
+    }
+    function resetStyles(el) {
+      const initialStyles = el._gExpandInitialStyles;
+      initialStyles && (el.style.height = initialStyles.height, el.style.overflow = initialStyles.overflow, el.style.transitionDuration = initialStyles.transitionDuration, el.style.transitionProperty = initialStyles.transitionProperty, el.style.transitionTimingFunction = initialStyles.transitionTimingFunction, delete el._gExpandInitialStyles);
+    }
+    function cancelRunningTransition(el) {
+      var _a;
+      (_a = el._gExpandCancel) == null || _a.call(el), delete el._gExpandCancel;
+    }
+    function prepareTransition(el, phase) {
+      const duration = getDuration(el, phase);
+      return el.style.overflow = "hidden", el.style.transitionProperty = "height", el.style.transitionDuration = `${duration}ms`, el.style.transitionTimingFunction = getEasing(phase), duration;
+    }
+    function waitForHeightTransition(el, duration, done) {
+      let finished = !1, timeout = 0;
+      const finish = () => {
+        finished || (finished = !0, window.clearTimeout(timeout), el.removeEventListener("transitionend", onTransitionEnd), delete el._gExpandCancel, done());
+      }, onTransitionEnd = (event) => {
+        event.target !== el || event.propertyName !== "height" || finish();
+      };
+      if (duration <= 0) {
+        finish();
+        return;
+      }
+      el.addEventListener("transitionend", onTransitionEnd), timeout = window.setTimeout(finish, duration + 80), el._gExpandCancel = finish;
+    }
+    function onBeforeEnter(el) {
+      emit("before-enter", el);
+    }
+    function onEnter(el, done) {
+      if (!isClientHTMLElement(el)) {
+        done();
+        return;
+      }
+      const element = el;
+      if (cancelRunningTransition(element), saveInitialStyles(element), isDisabled.value) {
+        done();
+        return;
+      }
+      element.style.height = "0";
+      const duration = prepareTransition(element, "enter");
+      element.offsetHeight, requestAnimationFrame(() => {
+        element.style.height = `${element.scrollHeight}px`;
+      }), waitForHeightTransition(element, duration, done);
+    }
+    function onAfterEnter(el) {
+      isClientHTMLElement(el) && resetStyles(el), emit("after-enter", el);
+    }
+    function onBeforeLeave(el) {
+      emit("before-leave", el);
+    }
+    function onLeave(el, done) {
+      if (!isClientHTMLElement(el)) {
+        done();
+        return;
+      }
+      const element = el;
+      if (cancelRunningTransition(element), saveInitialStyles(element), isDisabled.value) {
+        done();
+        return;
+      }
+      element.style.height = `${element.offsetHeight}px`;
+      const duration = prepareTransition(element, "leave");
+      element.offsetHeight, requestAnimationFrame(() => {
+        element.style.height = "0";
+      }), emit("leave", el), waitForHeightTransition(element, duration, done);
+    }
+    function onAfterLeave(el) {
+      isClientHTMLElement(el) && resetStyles(el), emit("after-leave", el);
+    }
+    function onEnterCancelled(el) {
+      isClientHTMLElement(el) && (cancelRunningTransition(el), resetStyles(el)), emit("enter-cancelled", el);
+    }
+    function onLeaveCancelled(el) {
+      isClientHTMLElement(el) && (cancelRunningTransition(el), resetStyles(el)), emit("leave-cancelled", el);
+    }
+    return (_ctx, _cache) => (openBlock(), createBlock(Transition, mergeProps(unref(attrs), {
+      css: !1,
+      appear: resolvedTransition.value.appear,
+      mode: transitionMode.value,
+      onBeforeEnter,
+      onEnter,
+      onAfterEnter,
+      onBeforeLeave,
+      onLeave,
+      onAfterLeave,
+      onEnterCancelled,
+      onLeaveCancelled
+    }), {
+      default: withCtx(() => [
+        renderSlot(_ctx.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["appear", "mode"]));
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/GForm.vue_vue_type_style_index_0_lang-BzOWdjzk.cjs

@@ -0,0 +1 @@
+"use strict";const vue=require("vue"),context=require("./context-obVnJalQ.cjs"),propsFactory=require("./propsFactory-DT6-QS4L.cjs"),makeFormProps=propsFactory.propsFactory({name:String,preventDefault:{type:Boolean,default:!0},validateOnSubmit:{type:Boolean,default:!0},validateOn:{type:String,default:"blur"},disabled:{type:Boolean,default:!1},scrollToError:{type:Boolean,default:!1},focusFirstError:{type:Boolean,default:!1},noValidate:{type:Boolean,default:!0}}),_hoisted_1=["name","novalidate"],_sfc_main=vue.defineComponent({inheritAttrs:!1,__name:"GForm",props:makeFormProps(),emits:["submit","submit-valid","submit-invalid","reset"],setup(__props,{expose:__expose,emit:__emit}){const props=__props,emit=__emit,attrs=vue.useAttrs(),formRef=vue.ref();context.provideFormContext({disabled:vue.toRef(props,"disabled"),validateOn:vue.toRef(props,"validateOn")});const validation=context.ve({},{},props.name),errors=vue.computed(()=>collectErrors(validation.value)),firstError=vue.computed(()=>errors.value[0]),slotProps=vue.computed(()=>({$v:validation.value,valid:validation.value.$valid,invalid:validation.value.$invalid,pending:validation.value.$pending,dirty:validation.value.$dirty,error:validation.value.$error,errors:errors.value,errorCount:errors.value.length,firstError:firstError.value,disabled:props.disabled,validate,reset,touch,resetValidation}));function collectErrors(node,prefix=""){const localErrors=Object.entries(node.$errors??{}).flatMap(([field,messages])=>{const path=[prefix,field].filter(Boolean).join("."),normalizedMessages=messages??[];return normalizedMessages.map(message=>({path,message,messages:normalizedMessages}))}),childErrors=Object.entries(node.$children??{}).flatMap(([childName,childNode])=>{const path=[prefix,childName].filter(Boolean).join(".");return collectErrors(childNode,path)});return[...localErrors,...childErrors]}function touch(){validation.value.$touch()}function reset(){validation.value.$reset()}function resetValidation(){validation.value.$resetValidation()}async function validate(){return validation.value.$validate()}async function onSubmit(event){const submitEvent=event;if(props.preventDefault&&submitEvent.preventDefault(),emit("submit",submitEvent,validation.value),!props.validateOnSubmit)return;if(await validate()){emit("submit-valid",submitEvent,validation.value);return}emit("submit-invalid",submitEvent,validation.value),await revealFirstError()}function onReset(event){reset(),emit("reset",event,validation.value)}async function revealFirstError(){var _a;if(!props.scrollToError&&!props.focusFirstError)return;await vue.nextTick();const invalidElement=(_a=formRef.value)==null?void 0:_a.querySelector('[data-g-validation-error="true"], [aria-invalid="true"]');if(!invalidElement||(props.scrollToError&&invalidElement.scrollIntoView({block:"center",behavior:"smooth"}),!props.focusFirstError))return;const focusableElement=invalidElement.matches('input, textarea, select, button, [tabindex]:not([tabindex="-1"])')?invalidElement:invalidElement.querySelector('input, textarea, select, button, [tabindex]:not([tabindex="-1"])');focusableElement==null||focusableElement.focus({preventScroll:props.scrollToError})}return __expose({$v:validation,validate,reset,touch,resetValidation}),(_ctx,_cache)=>(vue.openBlock(),vue.createElementBlock("form",vue.mergeProps({ref_key:"formRef",ref:formRef},vue.unref(attrs),{class:"g-form",name:props.name,novalidate:props.noValidate,onSubmit,onReset}),[vue.renderSlot(_ctx.$slots,"default",vue.normalizeProps(vue.guardReactiveProps(slotProps.value)))],16,_hoisted_1))}});exports._sfc_main=_sfc_main;

package/dist/GForm.vue_vue_type_style_index_0_lang-DpPM5snQ.js

@@ -0,0 +1,149 @@
+import { defineComponent, useAttrs, ref, toRef, computed, openBlock, createElementBlock, mergeProps, unref, renderSlot, normalizeProps, guardReactiveProps, nextTick } from "vue";
+import { p as provideFormContext, v as ve } from "./context-DmyyyTi-.js";
+import { p as propsFactory } from "./propsFactory-FM5RGbLN.js";
+const makeFormProps = propsFactory({
+  name: String,
+  preventDefault: {
+    type: Boolean,
+    default: !0
+  },
+  validateOnSubmit: {
+    type: Boolean,
+    default: !0
+  },
+  validateOn: {
+    type: String,
+    default: "blur"
+  },
+  disabled: {
+    type: Boolean,
+    default: !1
+  },
+  scrollToError: {
+    type: Boolean,
+    default: !1
+  },
+  focusFirstError: {
+    type: Boolean,
+    default: !1
+  },
+  noValidate: {
+    type: Boolean,
+    default: !0
+  }
+}), _hoisted_1 = ["name", "novalidate"], _sfc_main = /* @__PURE__ */ defineComponent({
+  inheritAttrs: !1,
+  __name: "GForm",
+  props: makeFormProps(),
+  emits: ["submit", "submit-valid", "submit-invalid", "reset"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props, emit = __emit, attrs = useAttrs(), formRef = ref();
+    provideFormContext({
+      disabled: toRef(props, "disabled"),
+      validateOn: toRef(props, "validateOn")
+    });
+    const validation = ve(
+      {},
+      {},
+      props.name
+    ), errors = computed(() => collectErrors(validation.value)), firstError = computed(() => errors.value[0]), slotProps = computed(() => ({
+      $v: validation.value,
+      valid: validation.value.$valid,
+      invalid: validation.value.$invalid,
+      pending: validation.value.$pending,
+      dirty: validation.value.$dirty,
+      error: validation.value.$error,
+      errors: errors.value,
+      errorCount: errors.value.length,
+      firstError: firstError.value,
+      disabled: props.disabled,
+      validate,
+      reset,
+      touch,
+      resetValidation
+    }));
+    function collectErrors(node, prefix = "") {
+      const localErrors = Object.entries(node.$errors ?? {}).flatMap(
+        ([field, messages]) => {
+          const path = [prefix, field].filter(Boolean).join("."), normalizedMessages = messages ?? [];
+          return normalizedMessages.map((message) => ({
+            path,
+            message,
+            messages: normalizedMessages
+          }));
+        }
+      ), childErrors = Object.entries(node.$children ?? {}).flatMap(
+        ([childName, childNode]) => {
+          const path = [prefix, childName].filter(Boolean).join(".");
+          return collectErrors(childNode, path);
+        }
+      );
+      return [...localErrors, ...childErrors];
+    }
+    function touch() {
+      validation.value.$touch();
+    }
+    function reset() {
+      validation.value.$reset();
+    }
+    function resetValidation() {
+      validation.value.$resetValidation();
+    }
+    async function validate() {
+      return validation.value.$validate();
+    }
+    async function onSubmit(event) {
+      const submitEvent = event;
+      if (props.preventDefault && submitEvent.preventDefault(), emit("submit", submitEvent, validation.value), !props.validateOnSubmit) return;
+      if (await validate()) {
+        emit("submit-valid", submitEvent, validation.value);
+        return;
+      }
+      emit("submit-invalid", submitEvent, validation.value), await revealFirstError();
+    }
+    function onReset(event) {
+      reset(), emit("reset", event, validation.value);
+    }
+    async function revealFirstError() {
+      var _a;
+      if (!props.scrollToError && !props.focusFirstError) return;
+      await nextTick();
+      const invalidElement = (_a = formRef.value) == null ? void 0 : _a.querySelector(
+        '[data-g-validation-error="true"], [aria-invalid="true"]'
+      );
+      if (!invalidElement || (props.scrollToError && invalidElement.scrollIntoView({
+        block: "center",
+        behavior: "smooth"
+      }), !props.focusFirstError)) return;
+      const focusableElement = invalidElement.matches(
+        'input, textarea, select, button, [tabindex]:not([tabindex="-1"])'
+      ) ? invalidElement : invalidElement.querySelector(
+        'input, textarea, select, button, [tabindex]:not([tabindex="-1"])'
+      );
+      focusableElement == null || focusableElement.focus({
+        preventScroll: props.scrollToError
+      });
+    }
+    return __expose({
+      $v: validation,
+      validate,
+      reset,
+      touch,
+      resetValidation
+    }), (_ctx, _cache) => (openBlock(), createElementBlock("form", mergeProps({
+      ref_key: "formRef",
+      ref: formRef
+    }, unref(attrs), {
+      class: "g-form",
+      name: props.name,
+      novalidate: props.noValidate,
+      onSubmit,
+      onReset
+    }), [
+      renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)))
+    ], 16, _hoisted_1));
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/GGradientMaterial.vue_vue_type_style_index_0_lang-ChRL7BIo.js

@@ -0,0 +1,119 @@
+import { defineComponent, computed, openBlock, createBlock, normalizeStyle, normalizeClass, unref, withCtx, createElementVNode, createElementBlock, Fragment, renderList, createCommentVNode, renderSlot } from "vue";
+import GGradient from "./components/GGradient.mjs";
+import { d as useMaterial } from "./material-Cn0l9r_y.js";
+import { m as makeGlassProps, u as useGlass } from "./glass-CJjbKWWO.js";
+import { p as propsFactory } from "./propsFactory-FM5RGbLN.js";
+const makeGradientMaterialProps = propsFactory({
+  ...makeGlassProps(),
+  tag: {
+    type: String,
+    default: "div"
+  },
+  variant: {
+    type: String,
+    default: "gradient"
+  },
+  color: String,
+  state: String,
+  kind: {
+    type: String,
+    default: "surface"
+  },
+  gradientRecipe: String,
+  borderRadius: {
+    type: [Number, String],
+    default: 8
+  },
+  borderWidth: [Number, String],
+  placement: {
+    type: String,
+    default: "center"
+  },
+  rounded: Boolean,
+  glow: [Boolean, Number, String],
+  animateGlow: Boolean,
+  padding: {
+    type: [Number, String],
+    default: 0
+  },
+  shadow: Boolean,
+  dropShadow: Boolean,
+  morph: Boolean,
+  animationOptions: Object,
+  shadowOptions: Object,
+  dropShadowOptions: Object,
+  morphOptions: Object
+}), _hoisted_1 = { class: "g-gradient-material__surface" }, _hoisted_2 = {
+  key: 0,
+  class: "g-gradient-material__morph",
+  "aria-hidden": "true"
+}, _hoisted_3 = { class: "g-gradient-material__content" }, _sfc_main = /* @__PURE__ */ defineComponent({
+  name: "GGradientMaterial",
+  __name: "GGradientMaterial",
+  props: makeGradientMaterialProps(),
+  setup(__props) {
+    const props = __props, resolvedBorderWidth = computed(
+      () => props.borderWidth ?? (props.variant === "outlined" || props.variant === "glass" || props.glow || props.animateGlow ? 1 : 0)
+    ), { glassStyles } = useGlass(props), {
+      getMorphBlobStyle,
+      materialClasses,
+      materialStyles,
+      morphBlobs,
+      morphEnabled
+    } = useMaterial({
+      baseClass: "g-gradient-material",
+      color: () => props.color ?? props.state,
+      kind: () => props.kind,
+      recipe: () => props.gradientRecipe,
+      effects: () => !!(props.shadow || props.dropShadow || props.shadowOptions || props.dropShadowOptions || props.morph || props.morphOptions),
+      animations: () => !!props.animationOptions,
+      shadow: () => props.shadowOptions,
+      dropShadow: () => props.dropShadowOptions,
+      animation: () => props.animationOptions,
+      morph: () => props.morphOptions ?? props.morph,
+      borderRadius: () => props.borderRadius,
+      padding: () => props.padding
+    }), materialBorderAnimationStyles = computed(() => ({
+      "--g-gradient-border-animation": "var(--g-gradient-material-animation, none)"
+    })), materialRootStyles = computed(() => [
+      materialStyles.value,
+      props.variant === "glass" ? glassStyles.value : void 0,
+      materialBorderAnimationStyles.value
+    ]);
+    return (_ctx, _cache) => (openBlock(), createBlock(GGradient, {
+      "root-tag": _ctx.tag,
+      class: normalizeClass(["g-gradient-material", [unref(materialClasses), `g-gradient-material_${_ctx.variant}`]]),
+      style: normalizeStyle(materialRootStyles.value),
+      color: _ctx.color ?? _ctx.state,
+      state: _ctx.state,
+      "material-kind": _ctx.kind,
+      "gradient-recipe": _ctx.gradientRecipe,
+      "border-radius": _ctx.borderRadius,
+      "border-width": resolvedBorderWidth.value,
+      placement: _ctx.placement,
+      rounded: _ctx.rounded,
+      glow: _ctx.glow,
+      "animate-glow": _ctx.animateGlow,
+      "surface-fill": "transparent"
+    }, {
+      default: withCtx(() => [
+        createElementVNode("span", _hoisted_1, [
+          unref(morphEnabled) && _ctx.variant === "gradient" ? (openBlock(), createElementBlock("span", _hoisted_2, [
+            (openBlock(!0), createElementBlock(Fragment, null, renderList(unref(morphBlobs), (blob, index) => (openBlock(), createElementBlock("span", {
+              key: index,
+              class: "g-gradient-material__morph-blob",
+              style: normalizeStyle(unref(getMorphBlobStyle)(blob))
+            }, null, 4))), 128))
+          ])) : createCommentVNode("", !0),
+          createElementVNode("span", _hoisted_3, [
+            renderSlot(_ctx.$slots, "default")
+          ])
+        ])
+      ]),
+      _: 3
+    }, 8, ["root-tag", "class", "style", "color", "state", "material-kind", "gradient-recipe", "border-radius", "border-width", "placement", "rounded", "glow", "animate-glow"]));
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/GGradientMaterial.vue_vue_type_style_index_0_lang-DJcGdEVi.cjs

@@ -0,0 +1 @@
+"use strict";const vue=require("vue"),components_GGradient=require("./components/GGradient.cjs"),material=require("./material-CkThdnz0.cjs"),glass=require("./glass-CZEblMo2.cjs"),propsFactory=require("./propsFactory-DT6-QS4L.cjs"),makeGradientMaterialProps=propsFactory.propsFactory({...glass.makeGlassProps(),tag:{type:String,default:"div"},variant:{type:String,default:"gradient"},color:String,state:String,kind:{type:String,default:"surface"},gradientRecipe:String,borderRadius:{type:[Number,String],default:8},borderWidth:[Number,String],placement:{type:String,default:"center"},rounded:Boolean,glow:[Boolean,Number,String],animateGlow:Boolean,padding:{type:[Number,String],default:0},shadow:Boolean,dropShadow:Boolean,morph:Boolean,animationOptions:Object,shadowOptions:Object,dropShadowOptions:Object,morphOptions:Object}),_hoisted_1={class:"g-gradient-material__surface"},_hoisted_2={key:0,class:"g-gradient-material__morph","aria-hidden":"true"},_hoisted_3={class:"g-gradient-material__content"},_sfc_main=vue.defineComponent({name:"GGradientMaterial",__name:"GGradientMaterial",props:makeGradientMaterialProps(),setup(__props){const props=__props,resolvedBorderWidth=vue.computed(()=>props.borderWidth??(props.variant==="outlined"||props.variant==="glass"||props.glow||props.animateGlow?1:0)),{glassStyles}=glass.useGlass(props),{getMorphBlobStyle,materialClasses,materialStyles,morphBlobs,morphEnabled}=material.useMaterial({baseClass:"g-gradient-material",color:()=>props.color??props.state,kind:()=>props.kind,recipe:()=>props.gradientRecipe,effects:()=>!!(props.shadow||props.dropShadow||props.shadowOptions||props.dropShadowOptions||props.morph||props.morphOptions),animations:()=>!!props.animationOptions,shadow:()=>props.shadowOptions,dropShadow:()=>props.dropShadowOptions,animation:()=>props.animationOptions,morph:()=>props.morphOptions??props.morph,borderRadius:()=>props.borderRadius,padding:()=>props.padding}),materialBorderAnimationStyles=vue.computed(()=>({"--g-gradient-border-animation":"var(--g-gradient-material-animation, none)"})),materialRootStyles=vue.computed(()=>[materialStyles.value,props.variant==="glass"?glassStyles.value:void 0,materialBorderAnimationStyles.value]);return(_ctx,_cache)=>(vue.openBlock(),vue.createBlock(components_GGradient.default,{"root-tag":_ctx.tag,class:vue.normalizeClass(["g-gradient-material",[vue.unref(materialClasses),`g-gradient-material_${_ctx.variant}`]]),style:vue.normalizeStyle(materialRootStyles.value),color:_ctx.color??_ctx.state,state:_ctx.state,"material-kind":_ctx.kind,"gradient-recipe":_ctx.gradientRecipe,"border-radius":_ctx.borderRadius,"border-width":resolvedBorderWidth.value,placement:_ctx.placement,rounded:_ctx.rounded,glow:_ctx.glow,"animate-glow":_ctx.animateGlow,"surface-fill":"transparent"},{default:vue.withCtx(()=>[vue.createElementVNode("span",_hoisted_1,[vue.unref(morphEnabled)&&_ctx.variant==="gradient"?(vue.openBlock(),vue.createElementBlock("span",_hoisted_2,[(vue.openBlock(!0),vue.createElementBlock(vue.Fragment,null,vue.renderList(vue.unref(morphBlobs),(blob,index)=>(vue.openBlock(),vue.createElementBlock("span",{key:index,class:"g-gradient-material__morph-blob",style:vue.normalizeStyle(vue.unref(getMorphBlobStyle)(blob))},null,4))),128))])):vue.createCommentVNode("",!0),vue.createElementVNode("span",_hoisted_3,[vue.renderSlot(_ctx.$slots,"default")])])]),_:3},8,["root-tag","class","style","color","state","material-kind","gradient-recipe","border-radius","border-width","placement","rounded","glow","animate-glow"]))}});exports._sfc_main=_sfc_main;

package/dist/GInput.vue_vue_type_script_setup_true_lang-BHM4W0S8.js

@@ -0,0 +1,143 @@
+import { defineComponent, useModel, openBlock, createBlock, ref, computed, useSlots, toRef, mergeProps, unref, createSlots, withCtx, createCommentVNode, createElementVNode, renderList, renderSlot, mergeModels } from "vue";
+import { m as makeValidationProps, a as makeFieldSizeProps, b as makeFieldStateProps, c as makePLAFieldProps, u as useTextFieldComponent, G as GFieldBase } from "./textFieldComponent-gnbYgrX0.js";
+import GIcon from "./components/GIcon.mjs";
+import { _ as _export_sfc } from "./_plugin-vue_export-helper-B--vMWp3.js";
+import { m as makeDisabledProps } from "./disabled-CAV056h6.js";
+import { p as propsFactory } from "./propsFactory-FM5RGbLN.js";
+import { u as useTextFieldControl, G as GInputEmits } from "./textFieldControl-Cxnq3lo4.js";
+import { b as useMask } from "./index-DQ6stZ3U.js";
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "SwitchPassword",
+  props: {
+    modelValue: { type: Boolean, default: !1 },
+    modelModifiers: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props) {
+    const modelValue = useModel(__props, "modelValue");
+    return (_ctx, _cache) => (openBlock(), createBlock(GIcon, {
+      size: "16",
+      class: "switcher",
+      icon: modelValue.value ? "eye-off-outline" : "eye-outline",
+      onClick: _cache[0] || (_cache[0] = ($event) => modelValue.value = !modelValue.value)
+    }, null, 8, ["icon"]));
+  }
+}), SwitchPassword = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-39a394d5"]]), makeInputProps = propsFactory({
+  ...makeDisabledProps(),
+  ...makePLAFieldProps(),
+  ...makeFieldStateProps(),
+  ...makeFieldSizeProps(),
+  ...makeValidationProps(),
+  clearable: Boolean,
+  mask: [String, Array],
+  maskTokens: Object,
+  returnMaskedValue: {
+    type: Boolean,
+    default: !0
+  },
+  type: {
+    type: String,
+    default: "text"
+  }
+});
+function useInputControl(options) {
+  const passwordVisible = ref(!1), computedType = computed(() => options.type.value === "password" && passwordVisible.value ? "text" : options.type.value);
+  return {
+    passwordVisible,
+    computedType,
+    togglePasswordVisibility: () => {
+      passwordVisible.value = !passwordVisible.value;
+    }
+  };
+}
+const _hoisted_1 = ["id", "value", "type", "name", "disabled", "aria-invalid"], _sfc_main = /* @__PURE__ */ defineComponent({
+  inheritAttrs: !1,
+  __name: "GInput",
+  props: /* @__PURE__ */ mergeModels(makeInputProps(), {
+    modelValue: { default: "" },
+    modelModifiers: {}
+  }),
+  emits: /* @__PURE__ */ mergeModels(GInputEmits, ["update:modelValue"]),
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props, slots = useSlots(), emit = __emit, modelValue = useModel(__props, "modelValue"), { attrs, id, visibleSlotNames } = useTextFieldComponent(slots), { passwordVisible, computedType, togglePasswordVisibility } = useInputControl({
+      type: toRef(props, "type")
+    }), mask = useMask({
+      mask: toRef(props, "mask"),
+      tokens: toRef(props, "maskTokens"),
+      returnMaskedValue: toRef(props, "returnMaskedValue")
+    }), {
+      $v,
+      fieldProps,
+      inputValue,
+      handleInput,
+      handleChange,
+      handleFocus,
+      handleBlur,
+      handleClear
+    } = useTextFieldControl({
+      id,
+      props,
+      modelValue,
+      rules: toRef(props, "rules"),
+      message: toRef(props, "message"),
+      multiline: !1,
+      displayValue: () => mask.toDisplayValue(modelValue.value),
+      toModelValue: mask.toModelValue,
+      toDisplayValue: mask.toDisplayValue,
+      extraFieldProps: () => ({
+        type: computedType.value
+      }),
+      emitters: {
+        input: (value, event) => emit("input", value, event),
+        change: (value, event) => emit("change", value, event),
+        focus: (event) => emit("focus", event),
+        blur: (event) => emit("blur", event),
+        clear: () => emit("clear")
+      }
+    });
+    function handleTogglePassword(visible) {
+      togglePasswordVisibility(), emit("toggle-password", visible);
+    }
+    return __expose({
+      $v
+    }), (_ctx, _cache) => (openBlock(), createBlock(GFieldBase, mergeProps(unref(fieldProps), { onClear: unref(handleClear) }), createSlots({
+      control: withCtx(() => [
+        createElementVNode("input", mergeProps(unref(attrs), {
+          id: unref(id),
+          value: unref(inputValue),
+          type: unref(computedType),
+          name: unref(id),
+          disabled: unref(fieldProps).disabled,
+          "aria-invalid": unref(fieldProps).state === "error" || void 0,
+          class: "g-field-base__native",
+          onInput: _cache[0] || (_cache[0] = //@ts-ignore
+          (...args) => unref(handleInput) && unref(handleInput)(...args)),
+          onChange: _cache[1] || (_cache[1] = //@ts-ignore
+          (...args) => unref(handleChange) && unref(handleChange)(...args)),
+          onFocus: _cache[2] || (_cache[2] = //@ts-ignore
+          (...args) => unref(handleFocus) && unref(handleFocus)(...args)),
+          onBlur: _cache[3] || (_cache[3] = //@ts-ignore
+          (...args) => unref(handleBlur) && unref(handleBlur)(...args))
+        }), null, 16, _hoisted_1)
+      ]),
+      actions: withCtx(() => [
+        props.type === "password" ? (openBlock(), createBlock(SwitchPassword, {
+          key: 0,
+          "model-value": unref(passwordVisible),
+          "onUpdate:modelValue": handleTogglePassword
+        }, null, 8, ["model-value"])) : createCommentVNode("", !0)
+      ]),
+      _: 2
+    }, [
+      renderList(unref(visibleSlotNames), (slotName) => ({
+        name: slotName,
+        fn: withCtx(() => [
+          renderSlot(_ctx.$slots, slotName)
+        ])
+      }))
+    ]), 1040, ["onClear"]));
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/GInput.vue_vue_type_script_setup_true_lang-dMjIUhb1.cjs

@@ -0,0 +1 @@
+"use strict";const vue=require("vue"),textFieldComponent=require("./textFieldComponent-Ct4Z0dFr.cjs"),components_GIcon=require("./components/GIcon.cjs"),_pluginVue_exportHelper=require("./_plugin-vue_export-helper-D_jf5u0r.cjs"),disabled=require("./disabled-B_bAKgaM.cjs"),propsFactory=require("./propsFactory-DT6-QS4L.cjs"),textFieldControl=require("./textFieldControl-D0-pdxIY.cjs"),index=require("./index-YvJ0cd3f.cjs"),_sfc_main$1=vue.defineComponent({__name:"SwitchPassword",props:{modelValue:{type:Boolean,default:!1},modelModifiers:{}},emits:["update:modelValue"],setup(__props){const modelValue=vue.useModel(__props,"modelValue");return(_ctx,_cache)=>(vue.openBlock(),vue.createBlock(components_GIcon.default,{size:"16",class:"switcher",icon:modelValue.value?"eye-off-outline":"eye-outline",onClick:_cache[0]||(_cache[0]=$event=>modelValue.value=!modelValue.value)},null,8,["icon"]))}}),SwitchPassword=_pluginVue_exportHelper._export_sfc(_sfc_main$1,[["__scopeId","data-v-39a394d5"]]),makeInputProps=propsFactory.propsFactory({...disabled.makeDisabledProps(),...textFieldComponent.makePLAFieldProps(),...textFieldComponent.makeFieldStateProps(),...textFieldComponent.makeFieldSizeProps(),...textFieldComponent.makeValidationProps(),clearable:Boolean,mask:[String,Array],maskTokens:Object,returnMaskedValue:{type:Boolean,default:!0},type:{type:String,default:"text"}});function useInputControl(options){const passwordVisible=vue.ref(!1),computedType=vue.computed(()=>options.type.value==="password"&&passwordVisible.value?"text":options.type.value);return{passwordVisible,computedType,togglePasswordVisibility:()=>{passwordVisible.value=!passwordVisible.value}}}const _hoisted_1=["id","value","type","name","disabled","aria-invalid"],_sfc_main=vue.defineComponent({inheritAttrs:!1,__name:"GInput",props:vue.mergeModels(makeInputProps(),{modelValue:{default:""},modelModifiers:{}}),emits:vue.mergeModels(textFieldControl.GInputEmits,["update:modelValue"]),setup(__props,{expose:__expose,emit:__emit}){const props=__props,slots=vue.useSlots(),emit=__emit,modelValue=vue.useModel(__props,"modelValue"),{attrs,id,visibleSlotNames}=textFieldComponent.useTextFieldComponent(slots),{passwordVisible,computedType,togglePasswordVisibility}=useInputControl({type:vue.toRef(props,"type")}),mask=index.useMask({mask:vue.toRef(props,"mask"),tokens:vue.toRef(props,"maskTokens"),returnMaskedValue:vue.toRef(props,"returnMaskedValue")}),{$v,fieldProps,inputValue,handleInput,handleChange,handleFocus,handleBlur,handleClear}=textFieldControl.useTextFieldControl({id,props,modelValue,rules:vue.toRef(props,"rules"),message:vue.toRef(props,"message"),multiline:!1,displayValue:()=>mask.toDisplayValue(modelValue.value),toModelValue:mask.toModelValue,toDisplayValue:mask.toDisplayValue,extraFieldProps:()=>({type:computedType.value}),emitters:{input:(value,event)=>emit("input",value,event),change:(value,event)=>emit("change",value,event),focus:event=>emit("focus",event),blur:event=>emit("blur",event),clear:()=>emit("clear")}});function handleTogglePassword(visible){togglePasswordVisibility(),emit("toggle-password",visible)}return __expose({$v}),(_ctx,_cache)=>(vue.openBlock(),vue.createBlock(textFieldComponent.GFieldBase,vue.mergeProps(vue.unref(fieldProps),{onClear:vue.unref(handleClear)}),vue.createSlots({control:vue.withCtx(()=>[vue.createElementVNode("input",vue.mergeProps(vue.unref(attrs),{id:vue.unref(id),value:vue.unref(inputValue),type:vue.unref(computedType),name:vue.unref(id),disabled:vue.unref(fieldProps).disabled,"aria-invalid":vue.unref(fieldProps).state==="error"||void 0,class:"g-field-base__native",onInput:_cache[0]||(_cache[0]=(...args)=>vue.unref(handleInput)&&vue.unref(handleInput)(...args)),onChange:_cache[1]||(_cache[1]=(...args)=>vue.unref(handleChange)&&vue.unref(handleChange)(...args)),onFocus:_cache[2]||(_cache[2]=(...args)=>vue.unref(handleFocus)&&vue.unref(handleFocus)(...args)),onBlur:_cache[3]||(_cache[3]=(...args)=>vue.unref(handleBlur)&&vue.unref(handleBlur)(...args))}),null,16,_hoisted_1)]),actions:vue.withCtx(()=>[props.type==="password"?(vue.openBlock(),vue.createBlock(SwitchPassword,{key:0,"model-value":vue.unref(passwordVisible),"onUpdate:modelValue":handleTogglePassword},null,8,["model-value"])):vue.createCommentVNode("",!0)]),_:2},[vue.renderList(vue.unref(visibleSlotNames),slotName=>({name:slotName,fn:vue.withCtx(()=>[vue.renderSlot(_ctx.$slots,slotName)])}))]),1040,["onClear"]))}});exports._sfc_main=_sfc_main;