@variojs/vue 0.0.1 → 0.0.2

package/dist/features/watch.js

@@ -1,154 +1 @@
-/**
- * Watch 支持
- *
- * 在 Schema 节点上支持监听器，监听表达式变化并调用 methods
- *
- * 特性：
- * - 精细化依赖追踪：只追踪表达式中使用的状态路径
- * - 支持 immediate 和 deep 选项
- * - 自动清理：组件卸载时停止所有 watcher
- */
-import { watch } from 'vue';
-import { evaluate, parseExpression, extractDependencies } from '@vario/core';
-/**
- * 从表达式中提取依赖的状态路径
- */
-function extractExprDependencies(expr) {
-    try {
-        const ast = parseExpression(expr);
-        return extractDependencies(ast);
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * 根据依赖路径从响应式状态中读取值（触发依赖追踪）
- */
-function trackDependencies(state, deps) {
-    if (!state || deps.length === 0)
-        return;
-    for (const dep of deps) {
-        if (dep.endsWith('.*')) {
-            const basePath = dep.slice(0, -2);
-            const value = getNestedValue(state, basePath);
-            if (Array.isArray(value)) {
-                void value.length;
-            }
-            else if (value && typeof value === 'object') {
-                void Object.keys(value);
-            }
-        }
-        else if (dep.includes('.')) {
-            void getNestedValue(state, dep);
-        }
-        else {
-            void state[dep];
-        }
-    }
-}
-/**
- * 获取嵌套路径的值
- */
-function getNestedValue(obj, path) {
-    const parts = path.split('.');
-    let current = obj;
-    for (const part of parts) {
-        if (current == null)
-            return undefined;
-        current = current[part];
-    }
-    return current;
-}
-/**
- * 规范化 watch 配置
- */
-function normalizeWatchConfigs(watchDef) {
-    if (!watchDef)
-        return [];
-    const configs = [];
-    for (const [source, config] of Object.entries(watchDef)) {
-        const handlerName = typeof config === 'string' ? config : config.handler;
-        const options = typeof config === 'string'
-            ? {}
-            : {
-                immediate: config.immediate,
-                deep: config.deep
-            };
-        configs.push({
-            source,
-            handler: handlerName,
-            options,
-            deps: extractExprDependencies(source)
-        });
-    }
-    return configs;
-}
-/**
- * 为 Schema 节点创建监听器
- * 返回停止监听的函数数组
- *
- * @param schema Schema 节点
- * @param ctx 运行时上下文
- * @param getState 获取响应式状态的函数
- */
-export function createWatchers(schema, ctx, getState) {
-    const configs = normalizeWatchConfigs(schema.watch);
-    if (configs.length === 0) {
-        return [];
-    }
-    const stopHandles = [];
-    for (const config of configs) {
-        const { source, handler: handlerName, options, deps } = config;
-        const handler = ctx.$methods?.[handlerName];
-        if (!handler) {
-            console.warn(`[Vario] Watch handler "${handlerName}" not found in methods`);
-            continue;
-        }
-        // 创建 getter 函数（精细化依赖追踪）
-        const getter = () => {
-            try {
-                if (getState) {
-                    trackDependencies(getState(), deps);
-                }
-                return evaluate(source, ctx);
-            }
-            catch (error) {
-                console.warn(`[Vario] Watch source "${source}" evaluation error:`, error);
-                return undefined;
-            }
-        };
-        // 注册监听器
-        const stopHandle = watch(getter, (newValue, oldValue) => {
-            try {
-                const result = handler(ctx, { newValue, oldValue, source });
-                // 处理异步 handler
-                if (result && typeof result === 'object' && 'catch' in result) {
-                    result.catch((err) => {
-                        console.warn(`[Vario] Watch handler "${handlerName}" error:`, err);
-                    });
-                }
-            }
-            catch (err) {
-                console.warn(`[Vario] Watch handler "${handlerName}" error:`, err);
-            }
-        }, options);
-        stopHandles.push(stopHandle);
-    }
-    // 返回停止函数
-    return stopHandles.map(handle => () => handle());
-}
-/**
- * 批量停止所有 watcher
- */
-export function stopAllWatchers(stopHandles) {
-    stopHandles.forEach(stop => {
-        try {
-            stop();
-        }
-        catch {
-            // 忽略停止时的错误
-        }
-    });
-}
-//# sourceMappingURL=watch.js.map
+import{watch as w}from"vue";import{evaluate as W,parseExpression as V,extractDependencies as g}from"@vario/core";function $(e){try{const o=V(e);return g(o)}catch{return[]}}function b(e,o){if(!(!e||o.length===0))for(const r of o)if(r.endsWith(".*")){const t=r.slice(0,-2),n=f(e,t);Array.isArray(n)?n.length:n&&typeof n=="object"&&Object.keys(n)}else r.includes(".")?f(e,r):e[r]}function f(e,o){const r=o.split(".");let t=e;for(const n of r){if(t==null)return;t=t[n]}return t}function j(e){if(!e)return[];const o=[];for(const[r,t]of Object.entries(e)){const n=typeof t=="string"?t:t.handler,s=typeof t=="string"?{}:{immediate:t.immediate,deep:t.deep};o.push({source:r,handler:n,options:s,deps:$(r)})}return o}function x(e,o,r){const t=j(e.watch);if(t.length===0)return[];const n=[];for(const s of t){const{source:i,handler:a,options:l,deps:p}=s,h=o.$methods?.[a];if(!h){console.warn(`[Vario] Watch handler "${a}" not found in methods`);continue}const d=w(()=>{try{return r&&b(r(),p),W(i,o)}catch(u){console.warn(`[Vario] Watch source "${i}" evaluation error:`,u);return}},(u,m)=>{try{const c=h(o,{newValue:u,oldValue:m,source:i});c&&typeof c=="object"&&"catch"in c&&c.catch(y=>{console.warn(`[Vario] Watch handler "${a}" error:`,y)})}catch(c){console.warn(`[Vario] Watch handler "${a}" error:`,c)}},l);n.push(d)}return n.map(s=>()=>s())}function v(e){e.forEach(o=>{try{o()}catch{}})}export{x as createWatchers,v as stopAllWatchers};

package/dist/index.js

@@ -1,24 +1 @@
-/**
- * Vario Vue Renderer
- *
- * Vue 3 integration backend for rendering Vario Schemas.
- *
- * 深度集成 Vue 3 特性：
- * - ref: 模板引用（声明映射到 Vue ref）
- * - 生命周期钩子（声明映射到 Vue 钩子）
- * - provide/inject: 依赖注入（声明映射到 Vue API）
- * - teleport: 传送
- * - transition: 过渡动画
- * - keep-alive: 缓存
- *
- * 注意：computed 和 watch 应该在 Vue 组件中使用原生 API 定义，
- * 然后通过 useVario 的 computed 选项传入
- */
-export * from './renderer.js';
-export * from './composable.js';
-export * from './bindings.js';
-export * from './types.js';
-export * from './features/refs.js';
-export * from './features/teleport.js';
-export * from './features/provide-inject.js';
-//# sourceMappingURL=index.js.map
+export*from"./renderer.js";export*from"./composable.js";export*from"./bindings.js";export*from"./types.js";export*from"./features/refs.js";export*from"./features/teleport.js";export*from"./features/provide-inject.js";

package/dist/renderer.js

@@ -1,244 +1 @@
-/**
- * Vue renderer implementation
- *
- * 功能：
- * - Schema → VNode 转换
- * - 通用组件解析（支持全局注册的组件）
- * - 双向绑定处理
- * - 控制流转换（cond/show/loop）
- * - 事件处理
- * - 表达式求值
- */
-import { h, Fragment, Transition, KeepAlive } from 'vue';
-import { attachRef, RefsRegistry } from './features/refs.js';
-import { createTeleport, shouldTeleport } from './features/teleport.js';
-import { ModelPathResolver } from './features/path-resolver.js';
-import { ComponentResolver } from './features/component-resolver.js';
-import { ExpressionEvaluator } from './features/expression-evaluator.js';
-import { EventHandler } from './features/event-handler.js';
-import { AttrsBuilder } from './features/attrs-builder.js';
-import { LoopHandler } from './features/loop-handler.js';
-import { ChildrenResolver } from './features/children-resolver.js';
-import { LifecycleWrapper } from './features/lifecycle-wrapper.js';
-/**
- * Vue 渲染器
- * 将 Vario Schema 转换为 Vue VNode
- */
-export class VueRenderer {
-    refsRegistry;
-    getState;
-    // 功能模块
-    pathResolver;
-    componentResolver;
-    expressionEvaluator;
-    eventHandler;
-    attrsBuilder;
-    loopHandler;
-    childrenResolver;
-    lifecycleWrapper;
-    constructor(options = {}) {
-        this.getState = options.getState;
-        this.refsRegistry = options.refsRegistry || new RefsRegistry();
-        // modelPath 选项保留于 API，供后续路径解析扩展使用
-        // 初始化功能模块
-        // 优先级：components > app._context.components > instance?.appContext?.components
-        const globalComponents = options.components ||
-            options.app?._context?.components ||
-            options.instance?.appContext?.components ||
-            {};
-        this.componentResolver = new ComponentResolver(globalComponents);
-        this.expressionEvaluator = new ExpressionEvaluator();
-        this.eventHandler = new EventHandler((expr, ctx) => this.expressionEvaluator.evaluateExpr(expr, ctx));
-        this.pathResolver = new ModelPathResolver((expr, ctx) => this.expressionEvaluator.evaluateExpr(expr, ctx));
-        this.attrsBuilder = new AttrsBuilder(this.getState, this.pathResolver, this.eventHandler);
-        this.lifecycleWrapper = new LifecycleWrapper();
-        // LoopHandler 和 ChildrenResolver 需要 createVNode 方法，使用箭头函数绑定 this
-        const createVNodeFn = (schema, ctx, modelPathStack) => this.createVNode(schema, ctx, modelPathStack || []);
-        this.loopHandler = new LoopHandler(this.pathResolver, createVNodeFn, (expr, ctx) => this.expressionEvaluator.evaluateExpr(expr, ctx));
-        this.childrenResolver = new ChildrenResolver(createVNodeFn, this.expressionEvaluator);
-    }
-    /**
-     * 渲染 Schema 为 VNode
-     */
-    render(schema, ctx) {
-        const vnode = this.createVNode(schema, ctx);
-        // 如果返回 null，返回一个空的 Fragment 作为占位符
-        // Vue 需要有效的 VNode，不能是 null
-        if (vnode === null || vnode === undefined) {
-            return h(Fragment, null, []);
-        }
-        return vnode;
-    }
-    /**
-     * 创建 VNode
-     * @param schema Schema 节点
-     * @param ctx 运行时上下文
-     * @param modelPathStack 当前 model 路径栈（用于自动路径拼接）
-     */
-    createVNode(schema, ctx, modelPathStack = []) {
-        // 验证 schema 基本结构
-        if (!schema || typeof schema !== 'object') {
-            return h('div', { style: 'color: red; padding: 10px;' }, 'Invalid schema');
-        }
-        if (!schema.type) {
-            return h('div', { style: 'color: red; padding: 10px;' }, 'Schema missing type property');
-        }
-        // 处理条件渲染（优化：提前返回，避免不必要的处理）
-        if (schema.cond) {
-            try {
-                const condition = this.expressionEvaluator.evaluateExpr(schema.cond, ctx);
-                if (!condition) {
-                    // 条件不满足，返回 null（Vue 会正确处理 null VNode）
-                    return null;
-                }
-            }
-            catch (error) {
-                // 表达式求值错误，返回错误提示节点
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                return h('div', {
-                    style: 'color: red; padding: 10px; border: 1px solid red;'
-                }, `Condition evaluation error: ${errorMessage}`);
-            }
-        }
-        // 处理列表渲染
-        if (schema.loop) {
-            const loopVNode = this.loopHandler.createLoopVNode(schema, ctx, modelPathStack);
-            return loopVNode || null;
-        }
-        // 解析组件（先解析，用于双向绑定的自动检测）
-        const component = this.componentResolver.resolveComponent(schema.type);
-        // 确保 component 有效
-        if (!component) {
-            return h('div', { style: 'color: red; padding: 10px;' }, `Component "${schema.type}" not found`);
-        }
-        // 处理 Vue 特有的扩展
-        const vueSchema = schema;
-        // 处理 model 路径（更新路径栈，供子级使用）
-        // model 为 string 或 object+scope 时压栈
-        let currentModelPathStack = [...modelPathStack];
-        const scopePath = this.pathResolver.getScopePath(schema.model);
-        if (scopePath) {
-            currentModelPathStack = this.pathResolver.updateModelPathStack(scopePath, modelPathStack, ctx, schema);
-        }
-        // 构建属性（传入 component 和路径栈用于自动检测）
-        // buildAttrs 中会解析 model 路径，这里传入当前路径栈
-        let attrs = this.attrsBuilder.buildAttrs(schema, ctx, component, modelPathStack, (props, ctx) => this.childrenResolver.evalProps(props, ctx));
-        // 解析子节点（支持作用域插槽，传递路径栈）
-        let children = this.childrenResolver.resolveChildren(schema, ctx, currentModelPathStack);
-        // 处理可见性控制（v-show，优化：错误处理）
-        if (schema.show) {
-            try {
-                const isVisible = this.expressionEvaluator.evaluateExpr(schema.show, ctx);
-                if (!isVisible) {
-                    // 确保 style 是对象格式
-                    const currentStyle = attrs.style;
-                    if (typeof currentStyle === 'string') {
-                        // 如果 style 是字符串，转换为对象
-                        const styleObj = {};
-                        currentStyle.split(';').forEach(rule => {
-                            const [key, value] = rule.split(':').map(s => s.trim());
-                            if (key && value) {
-                                styleObj[key] = value;
-                            }
-                        });
-                        attrs.style = { ...styleObj, display: 'none' };
-                    }
-                    else {
-                        // style 已经是对象或未定义
-                        attrs.style = { ...(currentStyle || {}), display: 'none' };
-                    }
-                }
-            }
-            catch (error) {
-                // 表达式求值错误，隐藏元素并显示错误提示
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                console.warn(`Show expression evaluation error: ${errorMessage}`, schema);
-                // 默认隐藏元素
-                attrs.style = { ...(attrs.style || {}), display: 'none' };
-            }
-        }
-        // 确保 attrs 是对象（避免 undefined 导致的问题）
-        const safeAttrs = attrs || {};
-        // 处理 children：Vue 3 组件推荐使用函数插槽以获得更好的性能
-        let finalAttrs = safeAttrs;
-        let finalChildren = null;
-        if (children && typeof children === 'object' && !Array.isArray(children)) {
-            // 作用域插槽对象（已经是函数），直接使用
-            finalChildren = children;
-        }
-        else if (children !== undefined && children !== null) {
-            // 普通 children：对于组件，包装成函数插槽以避免警告
-            // 对于原生 DOM 元素，可以直接使用数组
-            const isNativeElement = typeof component === 'string';
-            if (isNativeElement) {
-                finalChildren = children;
-            }
-            else {
-                // Vue 3 组件推荐使用函数插槽
-                finalChildren = { default: () => children };
-            }
-        }
-        // 检查是否需要组件包装（生命周期、provide/inject 都需要在 setup 中处理）
-        const hasLifecycle = vueSchema.onMounted || vueSchema.onUnmounted || vueSchema.onUpdated ||
-            vueSchema.onBeforeMount || vueSchema.onBeforeUnmount || vueSchema.onBeforeUpdate;
-        const hasProvideInject = (vueSchema.provide && Object.keys(vueSchema.provide).length > 0) ||
-            (vueSchema.inject && (Array.isArray(vueSchema.inject) ? vueSchema.inject.length > 0 : Object.keys(vueSchema.inject).length > 0));
-        let vnode;
-        if (hasLifecycle || hasProvideInject) {
-            vnode = this.lifecycleWrapper.createComponentWithLifecycle(component, finalAttrs, finalChildren, vueSchema, ctx);
-        }
-        else {
-            try {
-                vnode = h(component, finalAttrs, finalChildren);
-            }
-            catch (error) {
-                return h('div', { style: 'color: red; padding: 10px;' }, `Failed to render "${schema.type}": ${error}`);
-            }
-        }
-        // 处理 ref
-        if (vueSchema.ref) {
-            vnode = attachRef(vnode, vueSchema, this.refsRegistry);
-        }
-        // 处理 keep-alive
-        if (vueSchema.keepAlive) {
-            const keepAliveProps = typeof vueSchema.keepAlive === 'object'
-                ? vueSchema.keepAlive
-                : {};
-            vnode = h(KeepAlive, keepAliveProps, () => vnode);
-        }
-        // 处理 transition
-        if (vueSchema.transition) {
-            const transitionProps = typeof vueSchema.transition === 'string'
-                ? { name: vueSchema.transition }
-                : {
-                    ...vueSchema.transition,
-                    // 确保 duration 符合类型要求
-                    duration: vueSchema.transition.duration && typeof vueSchema.transition.duration === 'object'
-                        ? (vueSchema.transition.duration.enter && vueSchema.transition.duration.leave
-                            ? { enter: vueSchema.transition.duration.enter, leave: vueSchema.transition.duration.leave }
-                            : undefined)
-                        : vueSchema.transition.duration
-                };
-            vnode = h(Transition, transitionProps, () => vnode);
-        }
-        // 处理 teleport（必须在最外层）
-        if (shouldTeleport(vueSchema.teleport)) {
-            vnode = createTeleport(vueSchema.teleport, vnode);
-        }
-        return vnode;
-    }
-    /**
-     * 清除组件解析缓存
-     * 用于组件注册变更后的缓存失效
-     */
-    clearComponentCache() {
-        this.componentResolver.clearComponentCache();
-    }
-    /**
-     * 使特定组件的缓存失效
-     */
-    invalidateComponentCache(type) {
-        this.componentResolver.invalidateComponentCache(type);
-    }
-}
-//# sourceMappingURL=renderer.js.map
+import{h as a,Fragment as C,Transition as A,KeepAlive as w}from"vue";import{attachRef as b,RefsRegistry as j}from"./features/refs.js";import{createTeleport as S,shouldTeleport as V}from"./features/teleport.js";import{ModelPathResolver as N}from"./features/path-resolver.js";import{ComponentResolver as H}from"./features/component-resolver.js";import{ExpressionEvaluator as B}from"./features/expression-evaluator.js";import{EventHandler as M}from"./features/event-handler.js";import{AttrsBuilder as k}from"./features/attrs-builder.js";import{LoopHandler as P}from"./features/loop-handler.js";import{ChildrenResolver as L}from"./features/children-resolver.js";import{LifecycleWrapper as W}from"./features/lifecycle-wrapper.js";class Q{refsRegistry;getState;pathResolver;componentResolver;expressionEvaluator;eventHandler;attrsBuilder;loopHandler;childrenResolver;lifecycleWrapper;constructor(t={}){this.getState=t.getState,this.refsRegistry=t.refsRegistry||new j;const n=t.components||t.app?._context?.components||t.instance?.appContext?.components||{};this.componentResolver=new H(n),this.expressionEvaluator=new B,this.eventHandler=new M((o,e)=>this.expressionEvaluator.evaluateExpr(o,e)),this.pathResolver=new N((o,e)=>this.expressionEvaluator.evaluateExpr(o,e)),this.attrsBuilder=new k(this.getState,this.pathResolver,this.eventHandler),this.lifecycleWrapper=new W;const i=(o,e,f)=>this.createVNode(o,e,f||[]);this.loopHandler=new P(this.pathResolver,i,(o,e)=>this.expressionEvaluator.evaluateExpr(o,e)),this.childrenResolver=new L(i,this.expressionEvaluator)}render(t,n){const i=this.createVNode(t,n);return i??a(C,null,[])}createVNode(t,n,i=[]){if(!t||typeof t!="object")return a("div",{style:"color: red; padding: 10px;"},"Invalid schema");if(!t.type)return a("div",{style:"color: red; padding: 10px;"},"Schema missing type property");if(t.cond)try{if(!this.expressionEvaluator.evaluateExpr(t.cond,n))return null}catch(r){const l=r instanceof Error?r.message:String(r);return a("div",{style:"color: red; padding: 10px; border: 1px solid red;"},`Condition evaluation error: ${l}`)}if(t.loop)return this.loopHandler.createLoopVNode(t,n,i)||null;const o=this.componentResolver.resolveComponent(t.type);if(!o)return a("div",{style:"color: red; padding: 10px;"},`Component "${t.type}" not found`);const e=t;let f=[...i];const v=this.pathResolver.getScopePath(t.model);v&&(f=this.pathResolver.updateModelPathStack(v,i,n,t));let d=this.attrsBuilder.buildAttrs(t,n,o,i,(r,l)=>this.childrenResolver.evalProps(r,l)),p=this.childrenResolver.resolveChildren(t,n,f);if(t.show)try{if(!this.expressionEvaluator.evaluateExpr(t.show,n)){const l=d.style;if(typeof l=="string"){const h={};l.split(";").forEach(E=>{const[y,m]=E.split(":").map(x=>x.trim());y&&m&&(h[y]=m)}),d.style={...h,display:"none"}}else d.style={...l||{},display:"none"}}}catch(r){const l=r instanceof Error?r.message:String(r);console.warn(`Show expression evaluation error: ${l}`,t),d.style={...d.style||{},display:"none"}}let u=d||{},c=null;p&&typeof p=="object"&&!Array.isArray(p)?c=p:p!=null&&(typeof o=="string"?c=p:c={default:()=>p});const g=e.onMounted||e.onUnmounted||e.onUpdated||e.onBeforeMount||e.onBeforeUnmount||e.onBeforeUpdate,R=e.provide&&Object.keys(e.provide).length>0||e.inject&&(Array.isArray(e.inject)?e.inject.length>0:Object.keys(e.inject).length>0);let s;if(g||R)s=this.lifecycleWrapper.createComponentWithLifecycle(o,u,c,e,n);else try{s=a(o,u,c)}catch(r){return a("div",{style:"color: red; padding: 10px;"},`Failed to render "${t.type}": ${r}`)}if(e.ref&&(s=b(s,e,this.refsRegistry)),e.keepAlive){const r=typeof e.keepAlive=="object"?e.keepAlive:{};s=a(w,r,()=>s)}if(e.transition){const r=typeof e.transition=="string"?{name:e.transition}:{...e.transition,duration:e.transition.duration&&typeof e.transition.duration=="object"?e.transition.duration.enter&&e.transition.duration.leave?{enter:e.transition.duration.enter,leave:e.transition.duration.leave}:void 0:e.transition.duration};s=a(A,r,()=>s)}return V(e.teleport)&&(s=S(e.teleport,s)),s}clearComponentCache(){this.componentResolver.clearComponentCache()}invalidateComponentCache(t){this.componentResolver.invalidateComponentCache(t)}}export{Q as VueRenderer};

package/dist/types.js

@@ -1,16 +0,0 @@
-/**
- * Vue 特有的类型定义
- *
- * 扩展 SchemaNode 以支持 Vue 的特性：
- * - ref: 模板引用（声明映射到 Vue ref）
- * - 生命周期钩子（声明映射到 Vue 钩子）
- * - provide/inject: 依赖注入（声明映射到 Vue API）
- * - teleport: 传送
- * - transition: 过渡动画
- * - keep-alive: 缓存
- *
- * 注意：computed 和 watch 不在 Schema 中定义，
- * 应该在 Vue 组件中使用原生 API 定义，然后通过 useVario 的 computed 选项传入
- */
-export {};
-//# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@variojs/vue",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Vario Vue Renderer - Vue 3 integration for Vario Schema rendering",
   "type": "module",
   "main": "./dist/index.js",
@@ -14,6 +14,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "postbuild": "node ../../scripts/minify.js",
     "dev": "tsc --watch",
     "test": "NODE_OPTIONS=--max-old-space-size=4096 vitest run",
     "test:perf": "NODE_OPTIONS=--max-old-space-size=8192 vitest run __tests__/performance.test.ts",
@@ -21,10 +22,6 @@
     "test:watch": "vitest",
     "clean": "rm -rf dist"
   },
-  "dependencies": {
-    "@variojs/core": "^0.0.1",
-    "@variojs/schema": "^0.0.1"
-  },
   "devDependencies": {
     "typescript": "^5.3.3",
     "vitest": "^1.2.0",
@@ -37,5 +34,21 @@
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "peerDependencies": {
+    "@variojs/core": "^0.0.2",
+    "@variojs/schema": "^0.0.2",
+    "vue": "^3.4.0"
+  },
+  "peerDependenciesMeta": {
+    "@variojs/core": {
+      "optional": false
+    },
+    "@variojs/schema": {
+      "optional": false
+    },
+    "vue": {
+      "optional": false
+    }
   }
 }